Python入门
一、初识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): pass
class 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'>
-