一、初识Python
1.Python介绍
-
Python是解释型语言
-
Python（英国发音：/ˈpaɪθən/ 美国发音：/ˈpaɪθɑːn/），是一种广泛使用的高级编程语言，属于通用型编程语言，由吉多·范罗苏姆创造，第一版发布于1991年。可以视之为一种改良（加入一些其他编程语言的优点，如面向对象）的LISP。作为一种解释型语言，Python的设计哲学强调代码的可读性和简洁的语法（尤其是使用空格缩进划分代码块，而非使用大括号或者关键词）。相比于C++或Java，Python让开发者能够用更少的代码表达想法。不管是小型还是大型程序，该语言都试图让程序的结构清晰明了。
2.Python的用途
- WEB应用
- 爬虫程序
- 科学计算
- 自动化运营
- 云计算
- 人工智能
二、基本语法
1.一些注意点
-
在Python中严格区分大小写
-
Python中的每一行就是一条语句，每条语句以换行结束
-
Python中每一行语句不要过长（规范中建议每行不要超过80个字符）
-
一条语句可以分多行编写，多行编写时语句后边以\结尾
如：
print('he\ ll\ o') -
Python是缩进严格的语言，所以在Python中不要随便写缩进
-
在Python中使用#来表示注释，#后的内容都属于注释，注释的内容将会被解释器所忽略
2.变量与标识符
2.1 变量
变量（variable）变量可以用来保存字面量，并且变量中保存的字面量是不定的，变量本身没有任何意思，它会根据不同的字面量表示不同的意思
2.2 标识符
标识符 在Python中所有可以自主命名的内容都属于标识符，比如：变量名、函数名、类名
标识符必须遵循标识符的规范
-
标识符中可以含有字母、数字、但是不能使用数字开头
例子：a_1 _a1 1a -
标识符不能是Python中的关键字和保留字，也不建议使用Python中的函数名作为标识符,因为这样会导致函数被覆盖
-
命名规范：
在Python中注意遵循两种命名规范：
-
下划线命名法
所有字母小写，单词之间使用_分割
max_length min_length hello_world xxx_yyy_zzz -
帕斯卡命名法（大驼峰命名法）
首字母大写，每个单词开头字母大写，其余字母小写
MaxLength MinLength HelloWorld XxxYyyZzz注：如果使用不符合标准的标识符，将会报错 SyntaxError: invalid syntax
2.3数据类型
不可变数据： Number（数字）、String（[字符串]、Tuple（元组）
可变数据： List（列表）、Dictionary（字典）、Set（集合）
3.数值类型
-
在Python中所有的整数都是int类型
-
Python中的整数的大小没有限制，可以是一个无限大的整数
如：
c = 999999999999999999999999999999999999999999999 -
如果数字的长度过大，可以使用下划线作为分隔符
如：
c = 123_456_789
-
在Python中所有的小数都是float类型,对浮点数进行运算时，可能会得到一个不精确的结果
如：
c = 0.1 + 0.2 # 0.30000000000000004
4.字符串
4.1初识字符串
-
字符串必须使用引号引起来，不使用不是字符串，引号可以是双引号，也可以是单引号，但是注意不要混着用
-
相同的引号之间不能嵌套
如：
# s = "子曰:"学而时习之，乐呵乐呵！""这样写不对 s = '子曰:"学而时习之，乐呵乐呵！"' -
单引号和双引号不能跨行使用，三重引号可以换行，并且会保留字符串中的格式
如：
s = '锄禾日当午，\ 汗滴禾下土，\ 谁知盘中餐，\ 粒粒皆辛苦' s = '''锄禾日当午， 汗滴禾下土， 谁知盘中餐， 粒粒皆辛苦'''
4.2格式化字符串
-
字符串之间也可以进行加法运算，如果将两个字符串进行相加，则会自动将两个字符串拼接为一个，但是字符串不能和其他的类型进行加法运算，如果做了会出现异常
-
如果需要与数值类型进行拼接可以使用下面的几种方法
-
使用逗号进行拼接
a=1 print('a =',a) -
使用占位符
a=123.1844 print("a= %0.2f"%a) -
格式化字符串
a=100 print(f"a={a}")
-
-
在创建字符串时，可以在字符串中指定占位符
-
%s 在字符串中表示任意字符
-
%f 浮点数占位符
-
%d 整数占位符
如：
b = 'Hello %s'%'孙悟空' b = 'hello %s 你好 %s'%('tom','孙悟空') b = 'hello %3.5s'%'abcdefg' # %3.5s字符串的长度限制在3-5之间 b = 'hello %s'%123.456 b = 'hello %.2f'%123.456 b = 'hello %d'%123.95 -
-
格式化字符串，可以通过在字符串前添加一个f来创建一个格式化字符串,在格式化字符串中可以直接嵌入变量
如：
a=1 b=2 c = f'hello {a} {b}'
4.3复制字符串
字符串的复制（将字符串和数字相乘）
如：
a = a * 5#aaaaa
#如果将字符串和数字相乘，则解释器会将字符串重复指定的次数并返回
5.布尔类型与空值
-
布尔值主要用来做逻辑判断，布尔值一共有两个 True 和 False，布尔值实际上也属于整型，True就相当于1，False就相当于0
-
None（空值）
6.类型检查与类型转换
6.1类型检查
type()用来检查值的类型，该函数会将检查的结果作为返回值返回，可以通过变量来接收函数的返回值
如：
print(type(1)) # <class 'int'>
print(type(1.5)) # <class 'float'>
print(type(True)) # <class 'bool'>
print(type('hello')) # <class 'str'>
print(type(None)) # <class 'NoneType'>
6.2类型转换
类型转换四个函数 int() float() str() bool()
7.运算符
7.1算术运算符
- //表示整除
- **表示乘方
- / 除法运算符，运算时结果总会返回一个浮点类型
7.2逻辑运算符
- 注意写法
-
not 逻辑非
-
and 逻辑与 Python中的与运算是短路的与，如果第一个值为False，则不再看第二个值
如：
True and print('你猜我出来吗？') 第一个值是True，会看第二个值，所以print()会执行 False and print('你猜我出来吗？')第一个值是False，不会看第二个值，所以print()不会执行注：在python中 result = 1 < 2 < 3 # 相当于 1 < 2 and 2 < 3
-
or 逻辑或
如：
False or print('你猜我出来吗？') 第一个值为False，继续看第二个，所以打印语句执行 True or print('你猜我出来吗？') 第一个值为True，不看第二个，所以打印语句不执行
-
非布尔值的与或运算
当我们对非布尔值进行与或运算时，Python会将其当做布尔值运算，最终会返回原值
-
与运算的规则
- 与运算是找False的，如果第一个值是False，则不看第二个值
- 如果第一个值是False，则直接返回第一个值，否则返回第二个值
如：
# True and True result = 1 and 2 # 2 # True and False result = 1 and 0 # 0 # False and True result = 0 and 1 # 0 # False and False result = 0 and None # 0-
或运算的规则
- 或运算是找True的，如果第一个值是True，则不看第二个值
-
如果第一个值是True，则直接返回第一个值，否则返回第二个值
如：
# True or True result = 1 or 2 # 1 # True or False result = 1 or 0 # 1 # False or True result = 0 or 1 # 1 # False or False result = 0 or None # None -
7.3条件运算符
条件运算符（三元运算符）
-
语法： 语句1 if 条件表达式 else 语句2
-
执行流程：
条件运算符在执行时，会先对条件表达式进行求值判断
如果判断结果为True，则执行语句1，并返回执行结果
如果判断结果为False，则执行语句2，并返回执行结果如：
a = 30 b = 50 # print('a的值比较大！') if a > b else print('b的值比较大！') # 获取a和b之间的较大值 max = (a if a > b else b)
7.4关系运算符
- is 比较两个对象是否是同一个对象，比较的是对象的id
- is not 比较两个对象是否不是同一个对象，比较的是对象的id
三、流程控制语句
1.条件判断语句
-
语法：if 条件表达式 :
代码块 -
默认情况下，if语句只会控制紧随其后的那条语句，如果希望if可以控制多条语句，则可以在if后跟着一个代码块
-
代码块
- 代码块中保存着一组代码，同一个代码块中的代码，要么都执行要么都不执行
- 代码块就是一种为代码分组的机制
- 如果要编写代码块，语句就不能紧随在后边，而是要写在下一行
- 代码块以缩进开始，直到代码恢复到之前的缩进级别时结束
示例：
if False : print(123) print(456) print(789) print(101112) if 10 < num < 20 : print('num比10大,num比20小！')
2.输入、输出函数
-
input()函数
该函数用来获取用户的输入input()调用后，程序会立即暂停，等待用户输入
用户输入完内容以后，点击回车程序才会继续向下执行
用户输入完成以后，其所输入的的内容会以返回值得形式返回
input()函数中可以设置一个字符串作为参数，这个字符串将会作为提示文字显示示例：
# 获取用户输入的用户名 username = input('请输入你的用户名:') # 判断用户名是否是admin if username == 'admin' : print('欢迎管理员光临！')注意：input()的返回值是一个字符串
-
print()函数
该函数用于向控制台输出
3.if-elif-else语句
3.1 if-else语句
- 语法：
if 条件表达式 :
代码块
else :
代码块 - 执行流程：
if-else语句在执行时，先对if后的条件表达式进行求值判断
如果为True，则执行if后的代码块
如果为False，则执行else后的代码块 - 示例：
age = 7
if age > 17 :
print('你已经成年了~~')
else :
print('你还未成年~~')
3.2 if-elif-else语句
- 语法：
if 条件表达式 :
代码块
elif 条件表达式 :
代码块
elif 条件表达式 :
代码块
elif 条件表达式 :
代码块
else :
代码块 - 示例：
age = 210
if age > 200 :
print('活着可真没劲呢！')
elif age > 100 :
print('你也是老大不小了！')
elif age >= 60 :
print('你已经退休了！')
elif age >= 30 :
print('你已经是中年了！')
elif age >= 18 :
print('你已经成年了！')
else :
print('你还是个小孩！')
4.循环语句
-
while循环
- 语法：
while 条件表达式 :
代码块
else :
代码块 - 执行流程：
while语句在执行时，会先对while后的条件表达式进行求值判断，
如果判断结果为True，则执行循环体（代码块），
循环体执行完毕，继续对条件表达式进行求值判断，以此类推，
直到判断结果为False，则循环终止，如果循环有对应的else，则执行else后的代码块 - 示例：
i = 0 while i < 10 : i += 1 print(i,'hello') else : print('else中的代码块') - 语法：
-
for循环
语法：
for 变量 in 序列 :
代码块 -
嵌套循环
示例：
i = 0 while i < 5: # 创建一个内层循环来控制图形的宽度 j = 0 while j < 5: print("* ",end='') j += 1 print() i += 1 -
break可以用来立即退出循环语句（包括else)
continue可以用来跳过当次循环
break和continue都是只对离他最近的循环起作用
pass是用来在判断或循环语句中占位的
示例：
i = 0 while i < 5: if i == 3: break print(i) i += 1 else : print('循环结束') i = 0 while i < 5: i += 1 if i == 2: continue print(i) else : print('循环结束') i = 0 if i < 5: pass
四、序列
1.列表
-
创建列表
my_list = [] # 创建了一个空列表- 一个列表中可以存储多个元素，也可以在创建列表时，来指定列表中的元素,当向列表中添加多个元素时，多个元素之间使用,隔开
my_list = [10,20,30,40,50] # 创建了一个保护有5个元素的列表-
列表中可以保存任意的对象
my_list = [10,'hello',True,None,[1,2,3],print] -
列表中的对象都会按照插入的顺序存储到列表中,我们可以通过索引（index）来获取列表中的元素
# 语法：my_list[索引] my_list[0] print(my_list[4]) # 如果使用的索引超过了最大的范围，会抛出异常 # print(my_list[5]) IndexError: list index out of range
-
获取列表的长度
len()函数，通过该函数可以获取列表的长度
示例：
my_list = [10,20,30,40,50] print(len(my_list))
2.切片
切片：指从现有列表中，获取一个子列表
- 列表的索引可以是负数
如果索引是负数，则从后向前获取元素，-1表示倒数第一个，-2表示倒数第二个 以此类推
-
通过切片来获取指定的元素
-
语法：列表[起始:结束]
- 通过切片获取元素时，会包括起始位置的元素，不会包括结束位置的元素
- 做切片操作时，总会返回一个新的列表，不会影响原来的列表
- 起始和结束位置的索引都可以省略不写
- 如果省略结束位置，则会一直截取到最后
- 如果省略起始位置，则会从第一个元素开始截取
- 如果起始位置和结束位置全部省略，则相当于创建了一个列表的副本
示例：
print(stus[1:]) print(stus[:3]) print(stus[:]) -
语法：列表[起始:结束:步长]
-
步长表示，每次获取元素的间隔，默认值是1
-
步长不能是0，但是可以是负数
-
如果是负数，则会从列表的后部向前边取元素
示例：
print(stus[0:5:3]) print(stus[::-1])
-
-
3.序列的一些通用操作
-
+可以将两个列表拼接为一个列表
my_list = [1,2,3] + [4,5,6]#[1, 2, 3, 4, 5, 6] -
*可以将列表重复指定的次数
my_list = [1,2,3] * 5#[1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3] -
in 和 not in
-
in用来检查指定元素是否存在于列表中
如果存在，返回True，否则返回False -
not in用来检查指定元素是否不在列表中
如果不在，返回True，否则返回False示例：
stus = ['孙悟空','猪八戒','沙和尚','唐僧','蜘蛛精','白骨精','沙和尚','沙和尚'] print('牛魔王' not in stus) print('牛魔王' in stus)
-
min() 获取列表中的最小值
-
max() 获取列表中的最大值
示例：
arr = [10,1,2,5,100,77] print(min(arr) , max(arr)) -
两个方法（method），方法和函数基本上是一样，只不过方法必须通过 对象.方法() 的形式调用
-
s.index() 获取指定元素在列表中的第一次出现时索引
print(stus.index('沙和尚')) -
s.count() 统计指定元素在列表中出现的次数
print(stus.count('牛魔王')) -
4.修改序列元素
-
直接通过索引来修改元素
stus = ['孙悟空','猪八戒','沙和尚','唐僧','蜘蛛精','白骨精'] stus[0] = 'sunwukong' stus[2] = '哈哈' -
通过del来删除元素
del stus[2] # 删除索引为2的元素 -
通过切片来修改列表
#在给切片进行赋值时，只能使用序列 stus[0:2] = ['牛魔王','红孩儿'] #使用新的元素替换旧元素 stus[0:2] = ['牛魔王','红孩儿','二郎神']#使用切片插入元素时，插入元素的个数不一定等于切片的长度 stus[0:0] = ['牛魔王'] # 向索引为0的位置插入元素 #当设置了步长时，序列中元素的个数必须和切片中元素的个数一致 stus[::2] = ['牛魔王','红孩儿','二郎神'] -
通过切片来删除元素
del stus[0:2] del stus[::2] stus[1:3] = []注： 以上操作，只适用于可变序列，但对于不可变序列，可以通过 list() 函数将其他的序列转换为list
5.列表的方法
-
append() 向列表的最后添加一个元素
stus = ['孙悟空','猪八戒','沙和尚','唐僧'] stus.append('唐僧')#['孙悟空', '猪八戒', '沙和尚', '唐僧', '唐僧'] -
insert() 向列表的指定位置插入一个元素
-
参数：
1.要插入的位置
2.要插入的元素 -
示例：
stus.insert(2,'唐僧')
-
-
extend() 向列表尾部追加一个序列，将列表中的每个元素都追加进来，在原有列表上增加。
stus = ['孙悟空','猪八戒','沙和尚','唐僧']
stus.extend(['唐僧','白骨精'])
#stus.extend('str')#追加一个字符串或者元组也可以
-
+与extend()在效果上具有相同的功能，但是实际上生成了一个新的列表来存放这两个列表的和
A = [1, 2, 3] B = [4, 5, 6] print(A+B)#[1, 2, 3, 4, 5, 6] print(A)#[1, 2, 3] -
clear() 清空序列
stus.clear() -
pop() 根据索引删除并返回被删除的元素
result = stus.pop(2) # 删除索引为2的元素 # result = stus.pop() # 删除最后一个 print('result =',result) -
remove() 删除指定值的元素，如果相同值得元素有多个，只会删除第一个
stus.remove('猪八戒') -
reverse() 用来反转列表
stus.reverse() -
sort() 用来对列表中的元素进行排序，默认是升序排列
如果需要降序排列，则需要传递一个reverse=True作为参数
my_list = [10,1,20,3,4,5,0,-2] print('修改前',my_list) my_list.sort(reverse=True) print('修改后',my_list)
6.遍历列表
-
while循环
stus = ['孙悟空','猪八戒','沙和尚','唐僧','白骨精','蜘蛛精'] i = 0 while i < len(stus): print(stus[i]) i += 1 -
for循环
-
语法：
for 变量 in 序列 :
代码块 -
示例:
for s in stus : print(s)
-
7.range
-
**range() **是一个函数，可以用来生成一个自然数的序列
-
该函数需要三个参数
-
起始位置（可以省略，默认是0）
-
结束位置
-
步长（可以省略，默认是1）
-
-
示例：
r = range(5) # 生成一个这样的序列[0,1,2,3,4] r = range(0,10,2) r = range(10,0,-1) -
应用
-
通过range()可以创建一个执行指定次数的for循环
-
示例：
for i in range(30): print(i)
-
8.元组
-
元组 tuple 一个不可变的序列 它的操作的方式基本上和列表是一致的
-
创建元组
-
使用()来创建元组
my_tuple = () # 创建了一个空元组 print(my_tuple,type(my_tuple)) # <class 'tuple'> my_tuple = (1,2,3,4,5) # 创建了一个5个元素的元组 -
元组是不可变对象，不能尝试为元组中的元素重新赋值
my_tuple[3] = 10 #TypeError: 'tuple' object does not support item assignment -
当元组不是空元组时，括号可以省略 如果元组不是空元组，它里边至少要有一个,
my_tuple = 10,20,30,40 my_tuple = 40, -
元组中可以保存任意的对象
t=(1,"ddda",[1,"dd",'a']) print(t,type(t))#(1, 'ddda', [1, 'dd', 'a']) <class 'tuple'>
-
-
元组的解包（解构）
-
解包指就是将元组当中每一个元素都赋值给一个变量
my_tuple = 10 , 20 , 30 , 40 a,b,c,d = my_tuple print("a =",a) print("b =",b) print("c =",c) print("d =",d) -
交互a 和 b的值，这时我们就可以利用元组的解包
a = 100 b = 300 a , b = b , a -
在对一个元组进行解包时，变量的数量不一定必须和元组中的元素的数量一致，也可以在变量前边添加一个*，这样变量将会获取元组中所有剩余的元素
a , b , *c = my_tuple a , *b , c = my_tuple *a , b , c = my_tuple a , b , *c = [1,2,3,4,5,6,7] a , b , *c = 'hello world'注：不能同时出现两个或以上的*变量 否则会报错
-
五、字典
1.字典简介
- 字典属于一种新的数据结构，称为映射（mapping）
- 字典的作用和列表类似，都是用来存储对象的容器
- 列表存储数据的性能很好，但是查询数据的性能的很差， 在查询元素时，字典的效率是非常快的
2.创建字典
-
使用 {} 来创建字典
d = {} # 创建了一个空字典-
语法：
-
字典的值可以是任意对象
-
字典的键可以是任意的不可变对象（int、str、bool、tuple ...），但是一般我们都会使用str
-
字典的键是不能重复的，如果出现重复的后边的会替换到前边的
-
示例：
d = {'name':'孙悟空' , 'age':18 , 'gender':'男' , 'name':'sunwukong'} -
可以根据键来获取值
print(d['name'],d['age'],d['gender'])注：如果使用了字典中不存在的键，会报错
-
-
使用 dict()函数来创建字典
-
每一个参数都是一个键值对，参数名就是键，参数名就是值（这种方式创建的字典，key都是字符串）
-
示例：
d = dict(name='孙悟空',age=18,gender='男')
-
-
也可以将一个包含有双值子序列的序列转换为字典
-
双值序列，序列中只有两个值，[1,2] ('a',3) 'ab'
-
子序列，如果序列中的元素也是序列，那么我们就称这个元素为子序列
-
示例：
d = dict([('name','孙悟饭'),('age',18)])
-
3.字典的使用
-
len() 获取字典中键值对的个数
print(len(d)) -
in 检查字典中是否包含指定的键
not in 检查字典中是否不包含指定的键
print('hello' in d) -
获取字典中的值，根据键来获取值
-
语法：d[key]
print(d['age']) -
通过[]来获取值时，如果键不存在，会抛出异常 KeyError
-
-
get(key, default) 该方法用来根据键来获取字典中的值,如果值不在字典中返回默认值。
-
如果获取的键在字典中不存在，会返回None
-
也可以指定一个默认值，来作为第二个参数，这样获取不到值时将会返回默认值
-
示例：
print(d.get('name')) print(d.get('hello','默认值'))
-
-
setdefault(key, default) 可以用来向字典中添加key-value
-
如果key已经存在于字典中，则返回key的值，不会对字典做任何操作
-
如果key不存在，则向字典中添加这个key，并设置value
-
示例：
result = d.setdefault('name','猪八戒') result = d.setdefault('hello','猪八戒')
-
-
update([other])
-
将其他的字典中的key-value添加到当前字典中
-
如果有重复的key，则后边的会替换到当前的
-
示例：
d = {'a':1,'b':2,'c':3} d2 = {'d':4,'e':5,'f':6, 'a':7} d.update(d2)
-
-
删除，可以使用 del 来删除字典中的 key-value
del d['a'] del d['b'] -
popitem() 随机删除字典中的一个键值对，一般都会删除最后一个键值对
-
删除之后，它会将删除的key-value作为返回值返回
-
返回的是一个元组，元组中有两个元素，第一个元素是删除的key，第二个是删除的value
-
当使用popitem()删除一个空字典时，会抛出异常 KeyError: 'popitem(): dictionary is empty'
-
示例：
d.popitem() result = d.popitem()
- pop(key, default) 根据key删除字典中的key-value
-
会将被删除的value返回
-
如果删除不存在的key，会抛出异常
-
如果指定了默认值，再删除不存在的key时，不会报错，而是直接返回默认值
-
示例：
result = d.pop('d') result = d.pop('z','这是默认值')
-
clear() 用来清空字典
d.clear() -
copy() 该方法用于对字典进行浅复制
-
复制以后的对象，和原对象是独立，修改一个不会影响另一个
-
注意，浅复制会简单复制对象内部的值，如果值也是一个可变对象，这个可变对象不会被复制
-
示例：
d = {'a':1,'b':2,'c':3} d2 = d.copy() # d['a'] = 100 d = {'a':{'name':'孙悟空','age':18},'b':2,'c':3} d2 = d.copy() d2['a']['name'] = '猪八戒' print('d = ',d , id(d)) print('d2 = ',d2 , id(d2))
-
4.遍历字典
-
keys() 该方法会返回字典的所有的key
-
该方法会返回一个序列，序列中保存有字典的所有的键
-
示例：
d = {'name':'孙悟空','age':18,'gender':'男'} # 通过遍历keys()来获取所有的键 for k in d.keys() : print(k , d[k])
-
-
values()
-
该方法会返回一个序列，序列中保存有字典的左右的值
-
示例：
for v in d.values(): print(v)
-
-
items()
-
该方法会返回字典中所有的项
-
它会返回一个序列，序列中包含有双值子序列,双值分别是,字典中的key和value
-
示例：
for k,v in d.items() : print(k , '=' , v)
-
六、集合
1.集合简介
- 集合（set）是一个无序的不重复元素序列。集合和列表非常相似
- 集合和列表的不同点：
- 集合中只能存储不可变对象
- 集合中存储的对象是无序（不是按照元素的插入顺序保存）
- 集合中不能也不会出现重复的元素
2.创建集合
-
使用 {} 来创建集合
s = {10,3,5,1,2,1,2,3,1,1,1,1} print(s) # {1, 2, 3, 5, 10} print(type(s)) # <class 'set'>注：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典
-
使用 set() 函数来创建集合
-
创建空集合
s = set() print(s) # set() print(type(s)) # <class 'set'> -
通过set()来将序列和字典转换为集合
s = set([1,2,3,4,5,1,1,2,3,4,5]) s = set('hello') s = set({'a':1,'b':2,'c':3}) # 使用set()将字典转换为集合时，只会包含字典中的键
-
3.集合的方法
-
len() 来获取集合中元素的数量
print(len(s)) -
使用in和not in来检查集合中的元素
print('c' in s) -
add() 向集合中添加元素
s.add(10) s.add(30) -
update() 将一个集合中的元素添加到当前集合中
-
update()可以传递序列或字典作为参数，字典只会使用键
-
示例：
s2 = set('hello') s.update(s2) s.update((10,20,30,40,50)) s.update({10:'ab',20:'bc',100:'cd',1000:'ef'})
-
-
pop() 随机删除并返回一个集合中的元素
result = s.pop() -
remove() 删除集合中的指定元素
s.remove(100) s.remove(1000) -
clear() 清空集合
s.clear() -
copy() 对集合进行浅复制
s1=s.copy() print(s1 , type(s1))
七、函数
1.函数简介
- 函数也是一个对象
- 函数可以用来保存一些可执行的代码，并且可以在需要时，对这些语句进行多次的调用
2.创建函数
-
语法：
def 函数名([形参1,形参2,...形参n]) :
代码块 -
函数名必须要符号标识符的规范（可以包含字母、数字、下划线、但是不能以数字开头）
-
函数中保存的代码不会立即执行，需要调用函数代码才会执行
-
调用函数：
函数对象(） -
示例：
def fn() : print('这是我的第一个函数！') print('hello') print('今天天气真不错！') print(fn) #<function fn at 0x03D2B618> print(type(fn)) #<class 'function'>
3.函数的参数
-
在定义函数时，可以在函数名后的()中定义数量不等的形参，多个形参之间使用,隔开
-
定义形参时，可以为形参指定默认值，指定了默认值以后，如果用户传递了参数则默认值没有任何作用，如果用户没有传递，则默认值就会生效
-
示例：
def mul(a,b,c): print(a*b*c) def fn(a = 5 , b = 10 , c = 20): print('a =',a) print('b =',b) print('c =',c) # fn(1 , 2 , 3) # fn(1 , 2) # fn() -
实参的传递方式
-
位置参数：将对应位置的实参复制给对应位置的形参
# 第一个实参赋值给第一个形参，第二个实参赋值给第二个形参... fn(1 , 2 , 3) -
关键字参数:可以不按照形参定义的顺序去传递，而直接根据参数名去传递参数
fn(b=1 , c=2 , a=3) print('hello' , end='')注：位置参数和关键字参数可以混合使用，混合使用关键字和位置参数时，必须将位置参数写到前面
-
-
不定长的参数
-
在定义函数时，可以在形参前边加上一个*****，这样这个形参将会获取到所有的实参， 它将会将所有的实参保存到一个元组中
def fn(*a): print("a =",a,type(a)) fn(1,2,3,4,5)#a = (1, 2, 3, 4, 5) <class 'tuple'> -
带星号的参数，可以和其他参数配合使用,但带星号的形参只能有一个
def fn2(a,b,*c): print('a =',a) print('b =',b) print('c =',c) # 第一个参数给a，第二个参数给b，剩下的都保存到c的元组中 -
可变参数不是必须写在最后，但是注意，带*的参数后的所有参数，必须以关键字参数的形式传递
def fn2(a,*b,c): print('a =',a) print('b =',b) print('c =',c) fn2(1,5,'d',6,c="f") -
*形参只能接收位置参数，而不能接收关键字参数
-
**形参可以接收其他的关键字参数，它会将这些参数统一保存到一个字典中
- 字典的key就是参数的名字，字典的value就是参数的值
- **形参只能有一个，并且必须写在所有参数的最后
def fn3(b,c,**a) : print('a =',a,type(a)) print('b =',b) print('c =',c) fn3(1,2,h=3,e=10,f=20) #a = {'h': 3, 'e': 10, 'f': 20} <class 'dict'> #b = 1 #c = 2 -
传递实参时，也可以在序列类型的参数前添加星号，这样他会自动将序列中的元素依次作为参数传递
-
这里要求序列中元素的个数必须和形参的个数的一致
def fn4(a,b,c): print('a =',a) print('b =',b) print('c =',c) t = (10,20,30) fn4(*t) d = {'a':100,'b':200,'c':300} fn4(**d)
-
-
4.函数返回值
-
返回值，返回值就是函数执行以后返回的结果
-
可以通过 return 来指定函数的返回值，return 后边可以跟任意的对象，返回值甚至可以是一个函数
-
如果仅仅写一个return 或者 不写return，则相当于return None ，在函数中，return后的代码都不会执行，return 一旦执行函数自动结束
-
示例：
def fn(): # return 'Hello' # return [1,2,3] # return {'k':'v'} def fn2() : print('hello') return fn2 # 返回值也可以是一个函数
5.文档字符串
-
文档字符串（doc str）
-
在定义函数时，可以在函数内部编写文档字符串，文档字符串就是函数的说明
-
当我们编写了文档字符串时，就可以通过help()函数来查看函数的说明
-
文档字符串非常简单，其实直接在函数的第一行写一个字符串就是文档字符串
def fn(a:int,b:bool,c:str='hello') -> int: ''' 这是一个文档字符串的示例 函数的作用：。。。。。 函数的参数： a，作用，类型，默认值。。。。 b，作用，类型，默认值。。。。 c，作用，类型，默认值。。。。 ''' return 10 help(fn)
-
-
help() 是Python中的内置函数
-
通过help()函数可以查询python中的函数的用法
-
语法：help(函数对象)
6.作用域
-
作用域（scope）指的是变量生效的区域
-
在Python中一共有两种作用域
- 全局作用域
- 全局作用域在程序执行时创建，在程序执行结束时销毁
- 所有函数以外的区域都是全局作用域
- 在全局作用域中定义的变量，都属于全局变量，全局变量可以在程序的任意位置被访问
- 函数作用域
- 函数作用域在函数调用时创建，在调用结束时销毁
- 函数每调用一次就会产生一个新的函数作用域
- 在函数作用域中定义的变量，都是局部变量，它只能在函数内部被访问
- 全局作用域
-
变量的查找
当我们使用变量时，会优先在当前作用域中寻找该变量，如果有则使用，如果没有则继续去上一级作用域中寻找，如果有则使用，如果依然没有则继续去上一级作用域中寻找，以此类推。直到找到全局作用域，依然没有找到，则会抛出异常
-
命名空间
-
命名空间指的是变量存储的位置，每一个变量都需要存储到指定的命名空间当中
-
每一个作用域都会有一个它对应的命名空间
-
全局命名空间，用来保存全局变量。函数命名空间用来保存函数中的变量
-
命名空间实际上就是一个字典，是一个专门用来存储变量的字典
-
locals()用来获取当前作用域的命名空间，如果在全局作用域中调用locals()则获取全局命名空间，如果在函数作用域中调用locals()则获取函数命名空间
scope = locals() # 当前命名空间 print(type(scope)) -
globals() 函数可以用来在任意位置获取全局命名空间
-
7.高阶函数
-
高阶函数：接收函数作为参数，或者将函数作为返回值的函数是高阶函数
-
当我们使用一个函数作为参数时，实际上是将指定的代码传递进了目标函数
def fn(func , lst) : ''' fn()函数可以将指定列表中的所有偶数获取出来，并保存到一个新列表中返回 参数： lst：要进行筛选的列表 ''' # 创建一个新列表 new_list = [] # 对列表进行筛选 for n in lst : # 判断n的奇偶 if func(n) : new_list.append(n) # if n > 5 : # new_list.append(n) # 返回新列表 return new_list def fn4(i): return i % 3 == 0 print(fn(fn4 , l)) -
匿名函数 lambda 函数表达式
-
lambda函数表达式专门用来创建一些简单的函数，他是函数创建的又一种方式
-
语法：lambda 参数列表 : 返回值
-
匿名函数一般都是作为参数使用，其他地方一般不会使用
def fn5(a , b): return a + b # (lambda a,b : a + b)(10,20) # 也可以将匿名函数赋值给一个变量，一般不会这么做 fn6 = lambda a,b : a + b # print(fn6(10,30))
-
-
sort() 该方法用来对列表中的元素进行排序
-
sort()方法默认是直接比较列表中的元素的大小
-
在sort()可以接收一个关键字参数 ， key
-
key需要一个函数作为参数，当设置了函数作为参数,每次都会以列表中的一个元素作为参数来调用函数，并且使用函数的返回值来比较元素的大小
l = ['bb','aaaa','c','ddddddddd','fff'] l.sort(key=len)
-
sorted()
-
这个函数和sort()的用法基本一致，但是sorted()可以对任意的序列进行排序
-
并且使用sorted()排序不会影响原来的对象，而是返回一个新对象
l = [2,5,'1',3,'6','4'] print('排序前:',l)#排序前: [2, 5, '1', 3, '6', '4'] print(sorted(l,key=int))#['1', 2, 3, '4', 5, '6'] print('排序后:',l)#排序后: [2, 5, '1', 3, '6', '4']
-
八、对象
1.什么是对象
- 对象是内存中专门用来存储数据的一块区域。
- 对象中可以存放各种数据（比如：数字、布尔值、代码）
- 对象由三部分组成：
- 对象的标识（id）
- 对象的类型（type）
- 对象的值（value）
2.类的简介
- 类，简单理解它就相当于一个图纸。在程序中我们需要根据类来创建对象
- 类也是一个对象，类就是一个用来创建对象的对象
- 类是type类型的对象，定义类实际上就是定义了一个type类型的对象
- 在类的代码块中，我们可以定义变量和函数
- 变量会成为该类实例的公共属性，所有的该类实例都可以通过 对象.属性名 的形式访问
- 函数会成为该类实例的公共方法，所有该类实例都可以通过 对象.方法名() 的形式调用方法
3.类的创建
-
使用class关键字来定义类，语法和函数很像
-
语法：
class 类名([父类]):
代码块class 类名([父类]) : 公共的属性... # 对象的初始化方法 def __init__(self,...): ... # 其他的方法 def method_1(self,...): ... def method_2(self,...): ... class MyClass(): pass mc = MyClass() # mc就是通过MyClass创建的对象，mc是MyClass的实例 -
isinstance() 用来检查一个对象是否是一个类的实例
result = isinstance(mc_2,MyClass) result = isinstance(mc_2,str) -
可以向对象中添加变量，对象中的变量称为属性
-
语法：对象.属性名 = 属性值
mc.name = '孙悟空' mc_2.name = '猪八戒'
-
-
在类的代码块中，我们可以定义变量和函数
-
在类中我们所定义的变量，将会成为所有的实例的公共属性
-
所有实例都可以访问这些变量
-
在类中也可以定义函数，类中的定义的函数，我们称为方法
class Person : name = 'swk' # 公共属性，所有实例都可以 def say_hello(self) : print('你好！我是 %s' %self.name)
-
4.对象的初始化
-
特殊方法
- 在类中可以定义一些特殊方法（魔术方法），特殊方法都是以__开头，__结尾的方法
- 特殊方法不需要我们自己调用，不要尝试去调用特殊方法,特殊方法将会在特殊的时刻自动调用
- 学习特殊方法：
- 特殊方法什么时候调用
- 特殊方法有什么作用
-
创建对象的流程(p1 = Person()的运行流程)
- 创建一个变量
- 在内存中创建一个新对象
- __init__(self)方法执行
- 将对象的id赋值给变量
-
__init__(self) 方法
-
init可以用来向新创建的对象中初始化属性
class Person : def __init__(self,name): # print(self) # 通过self向新建的对象中初始化属性 self.name = name def say_hello(self): print('大家好，我是%s'%self.name)
-
5.封装
-
什么是封装？
- 封装是面向对象的三大特性之一
- 封装指的是隐藏对象中一些不希望被外部所访问到的属性或方法
-
如何隐藏一个对象中的属性？
- 将对象的属性名，修改为一个外部不知道的名字
-
如何获取（修改）对象中的属性？
- 需要提供一个getter和setter方法使外部可以访问到属性
- getter 获取对象中的指定属性（get_属性名）
- setter 用来设置对象的指定属性（set_属性名）
- 需要提供一个getter和setter方法使外部可以访问到属性
-
示例1：
class Dog: ''' 表示狗的类 ''' def __init__(self , name , age): self.hidden_name = name self.hidden_age = age def say_hello(self): print('大家好，我是 %s'%self.hidden_name) def get_name(self): ''' get_name()用来获取对象的name属性 ''' # print('用户读取了属性') return self.hidden_name def set_name(self , name): # print('用户修改了属性') self.hidden_name = name def get_age(self): return self.hidden_age def set_age(self , age): if age > 0 : self.hidden_age = age -
可以为对象的属性使用双下划线开头，__xxx
-
双下划线开头的属性，是对象的隐藏属性，隐藏属性只能在类的内部访问，无法通过对象访问
-
其实隐藏属性只不过是Python自动为属性改了一个名字
-
实际上是将名字修改为了，_类名__属性名 比如 __name -> _Person__name
-
示例：
class Person: def __init__(self,name): self.__name = name def get_name(self): return self.__name def set_name(self , name): self.__name = name p = Person('孙悟空') print(p.__name) __开头的属性是隐藏属性，无法通过对象访问 p.__name = '猪八戒' print(p._Person__name) p._Person__name = '猪八戒' print(p.get_name())
-
-
封装最终版
class Person: def __init__(self,name,age): self._name = name self._age = age # property装饰器，用来将一个get方法，转换为对象的属性 # 添加为property装饰器以后，我们就可以像调用属性一样使用get方法 # 使用property装饰的方法，必须和属性名是一样的 @property def name(self): print('get方法执行了~~~') return self._name # setter方法的装饰器：@属性名.setter @name.setter def name(self , name): print('setter方法调用了') self._name = name @property def age(self): return self._age @age.setter def age(self , age): self._age = age p = Person('猪八戒',18) p.name = '孙悟空' p.age = 28 print(p.name,p.age)
6.继承
-
在创建类时，如果省略了父类，则默认父类为object
-
object是所有类的父类，所有类都继承自object
class Person(object): passclass Animal: def run(self): print('动物会跑~~~') def sleep(self): print('动物睡觉~~~') class Dog(Animal): def bark(self): print('汪汪汪~~~') def run(self): print('狗跑~~~~') d = Dog() -
issubclass() 检查一个类是否是另一个类的子类
print(issubclass(Animal , Dog)) print(issubclass(Animal , object)) -
isinstance() 用来检查一个对象是否是一个类的实例
-
如果这个类是这个对象的父类，也会返回True
-
所有的对象都是object的实例
print(isinstance(print , object))
-
-
父类中的所有方法都会被子类继承，包括特殊方法，也可以重写特殊方法
class Animal: def __init__(self,name): self._name = name def run(self): print('动物会跑~~~') def sleep(self): print('动物睡觉~~~') @property def name(self): return self._name @name.setter def name(self,name): self._name = name class Dog(Animal): def __init__(self,name,age): # 希望可以直接调用父类的__init__来初始化父类中定义的属性 # super() 可以用来获取当前类的父类， # 并且通过super()返回对象调用父类方法时，不需要传递self super().__init__(name) self._age = age def bark(self): print('汪汪汪~~~') def run(self): print('狗跑~~~~') @property def age(self): return self._age @age.setter def age(self,age): self._age = name d = Dog('旺财',18) print(d.name) print(d.age) -
在Python中是支持多重继承的，也就是我们可以为一个类同时指定多个父类
-
可以在类名的()后边添加多个类，来实现多重继承
-
多重继承，会使子类同时拥有多个父类，并且会获取到所有父类中的方法
-
如果多个父类中有同名的方法，则会现在第一个父类中寻找，然后找第二个，然后找第三个。。。
-
前边父类的方法会覆盖后边父类的方法
class A(object): def test(self): print('AAA') class B(object): def test(self): print('B中的test()方法~~') def test2(self): print('BBB') class C(A,B): pass -
类名.__bases__ 这个属性可以用来获取当前类的所有父类
print(B.__bases__) #(<class 'object'>,) print(C.__bases__) # (<class '__main__.A'>, <class '__main__.B'>
-
