Python学习笔记-Day5

Python学习笔记-Day5

列表

列表是一种有序的数据集合，可以通过索引访问到每一个列表的元素

常用函数：

1. append

2. insert

3. count

4. remove

5. del

6. extend

   1、append #默认在最后插入
   num = ['a','b','c','d','e','f']
   print(num)
   num.append('g')
   print(num)

   2、insert #指定索引值插入数据
   num = ['a','b','c','d','e','f']
   print(num)
   num.insert(0,'z')
   print(num)

   3、count #计算字母或者字符有列表中有多少个
   num = ['a','b','c','d','e','f']
   print(num)
   Num_count = num.count('d')
   print(Num_count)

   4、remove #指定删除哪个元素
   num = ['a','b','c','d','e','f']
   print(num)
   num.remove('d')
   print(num)

   5、del #指定索引值删除
   num = ['a','b','c','d','e','f']
   print(num)
   del num[0]
   print(num)

   6、extend #将两个列表合并成一个
   num = ['a','b','c','d','e','f']
   num1 = ['apple','banana']
   num.extend(num1)
   print(num)

元组

是一种特殊的列表，不同点是元组一旦创建就不能修改，类似列表的所有会修改列表内容的操作等对于元组都不再适用

num = tuple()
print(num)

num = ('a','b','c','d','e','f')  
print(num)  
num.append('n')  
print(num)

报错内容
('a', 'b', 'c', 'd', 'e', 'f')
Traceback (most recent call last):
  File "F:\xxx\xxx\python\Python爬虫\演示.py", line 3, in <module>
    num.append('n')
    ^^^^^^^^^^
AttributeError: 'tuple' object has no attribute 'append'


num = ('1',['1','2','3'],'linux')
元组里的数组是可以改变的

courses[0]可以访问元组的内容

如果想创建只有一个元组的元素，
t1 = ('c',)

集合

是一个无序不重复元素的数据集，对比列表的区别首先是无序的，不可以使用索引进行顺序的访问，另外一个特点是不能够有重复的数据。

空集合

num = set()

作用：

1. 去重

2. add添加数据和remove删除数据

3. 集合的运算

   'c' in courses 在courses集合中
   'c' not in courses 不在courses集合中

   以下是集合的运算代码 ：
   | ：或运算
   set1 = {1,2,3,4}
   set2 = {3,4,5,6}
   num = set1 | set2
   print(num)

   & ：并集运算
   set1 = {1,2,3,4}
   set2 = {3,4,5,6}
   num = set1 & set2
   print(num)

   • ：差集运算
     set1 = {1,2,3,4}
     set2 = {3,4,5,6}
     num = set1 - set2
     print(num)

   如何差集没弄懂，可以接着看下面这个
   A = {1, 2, 3, 4}
   B = {3, 4, 5, 6}
   print(A - B) - {1, 2}
   print(B - A) - {5, 6} ← 注意顺序很重要！

   ^ ：对称差集
   set1 = {1,2,3,4}
   set2 = {3,4,5,6}
   num = set1 ^ set2
   print(num)

   #add添加数据和remove删除数据
   courses = {'c','c','d','a'}
   courses.add('python')
   print(courses)
   courses.remove('c')
   print(courses)

字典

是无序的键值对集合。字典中的每一个元素都是一个key 和 一个 value 的组合，key 值在字典中必须是唯一的，因此可以很方便的从字典中使用 key 获得其对应的 value 的值。

numdict = {'num1':'a','num2':'b','num3':'c'}  
print(numdict['num1'])  
print(numdict['num2'])  
print(numdict['num3'])  
print(numdict.get('num1'))  
  
numdict['num1'] = 'go'  
print(numdict)  
  
#pop弹出数据，但是弹出的数据可以保存，如果在不赋值的情况下就是删除  
numdict.pop('num1')  
print(numdict)  
  
print(numdict.keys())  
print(numdict.values())

简单的数据类型转换

#数据类型转换  
a = '5'  
print(type(a))  
print(int(a))  
print(type(int(a)))  
  
b = '3.14'  
print(type(b))  
print(type(float(b)))  
print(type(int(float(b))))  
print(int(float(b)))

函数的定义

我们经常需要在同一个程序里多次复用相同的代码，函数可以很好的帮助我们完成这一点。我们在函数里写我们要重复做的事，然后我们在任何需要的时候调用它。函数有参数和返回值，在函数内部对参数进行处理，并把处理结果返回给调用者

1. 定义
2. 返回值
3. 作用域

函数的定义

格式：
def 函数名(参数1，参数2):
	return 返回的值
	
def 函数名(参数1，参数2):
	print('成功调用函数')

#函数的定义  
#定义一个求差的函数  
def char_count(str,char):  
    return str - char  
  
a = char_count(10,5)  
print(a)

name == 'main'的介绍

文件名:code1.py
def num1(str):

    num_list = set(str)

    for i in num_list:

        print(i,str.count(i))

#把它当成主程序运行

#这里如果是在当前文件中执行代码，那么就是主要程序，如果是在其他文件中执行代码，那么就是被调用的程序，只有别人调用了才执行，不调用不执行

#以下内容只有在当前文件下执行才能运行，主要用来测试
if __name__ == '__main__':
    str = input("请输入字符串：")
    num1(str)
   
文件名：code2.py
#导入模块，但是模块里的__name__ == __main__:不执行，一般也不调用
import code1

code.num1("I love Python")

__name__ 是 Python 的一个内置变量，表示当前模块的名称：

• 当直接运行 一个文件时，__name__ 的值是 '__main__'

• 当被导入 时，__name__ 的值是模块的文件名 （不含 .py 扩展名）

  name == 'main':解释
  如果出现这个代码，就说明这个代码只能在当前文件执行以下的代码，如果是导入模块，这个模块不会执行，只有调用的时候才会执行

优点：

1. 模块可重用：别人可以导入你的模块使用所有功能
2. 测试方便：可以直接运行模块进行测试
3. 避免副作用：导入时不会执行不必要的代码
4. 清晰的接口：明确区分模块功能和主程序逻辑

常见用途：

1. 单元测试代码
2. 演示示例
3. 命令行接口
4. 性能测试
5. 配置检查

作用域

a = 9

def num1():
    a = 10
    print(a)

print(a)
num1()

a = 9

def num1():
    global a
    a = 10
    print(a)

print(a)
num1()
print(a)

这里global会覆盖前面a的值，所以最后的值是10，因为global有全局变量的属性，所以相当于在当前文件的任何地方都可以调用

函数的参数：

1. 必选参数
2. 默认参数
3. 可变参数
4. 关键字参数

必选参数

#!/usr/bin/env python3  
  
def connect(ip,port):  
    print("ip",ip)  
    print("port",port)  
  
connect("127.0.0.1",8080)
另一种传参方法
connect(ip="192.168.1.1",port="8080")

默认参数

#!/usr/bin/env python3  
  
def connect(ip,port=8080):  
    print("ip",ip)  
    print("port",port)  
  
connect("127.0.0.1")

如果传参会覆盖掉默认的参数值
默认参数必须是在最后面写，后面不能再出现其他的必选参数

语法	接受的参数类型	打包成的数据结构
*args	位置参数	元组 (tuple)
**kwargs	关键字参数	字典 (dict)
可以理解为一个为元组，二个为字典

函数可变参数

#!/usr/bin/env python3  
  
def connect(ip,*ports):  
    print("ip",ip)  
    for p in ports:
		 print("port:",p)
  
connect("127.0.0.1",21,22,8080)

关键字参数

# *ports 收集位置参数到一个元组
# 收集关键字参数到一个字典中
def conect(ip,*ports,**kwargs):
    print("IP:", ip)
    for p in ports:
        print("Port:", p)
    for key,value in kwargs.items():
        print("{}:{}".format(key,value))


ip = "192.168.1.1"
ports = [21,22,23]
ps = {"user":"root","password":"123456"}
conect(ip,*ports,**ps)
  
解释如下：
# 调用函数，传入参数
# *ports 表示将ports中的元素作为位置参数传入函数
# *ports 接受任意数量的位置参数，并且都会被收集到一个名为ports的元组中，
# *ports :必须放在所有普通位置参数之后，所有关键字参数之前
# **ps 表示将ps中的元素作为关键字参数传入函数
  
# **ps 接受任意数量的关键字参数
# 这些参数会被收集到一个名为ps的字典中
# **ps 必须放在所有参数的最后

再次解释一下：

*ports 解包元组
ports = [21,22,23]  这是一个集合
*ps 将元组解包成多个位置参数的元组
相当于：connect("127.0.0.1", 21, 22, 80, 6397, **dict_list)


**ps  解包字典
ps = {"user":"root","password":"123456"} 是一个集合
**ps 将字典解包成多个关键字参数
相当于：connect("127.0.0.1", *ps, name='youzi', age='19')

简单记忆：

• 定义函数时：* 是"收集器"
• 调用函数时：* 是"拆包器"