一.基础知识
1.IPO程序编写方法(掌握)
2.print() 语法格式:(熟练)
print(value,....,sep='',end='\n',file=None)#1.使用 print 函数
a = 100 #变量 a 为100
b = 50 #变量 b 为50
print(90)
print(a) #输出变量 a 的值 100
print(a*b) #输出 a*b 的结果:5000
print('北京欢迎你!')
print("北京欢迎你!")
print('''北京欢迎你!''')
print("""北京欢迎你!""")
#2.不换行一次输出多个
print(a,b,'北京欢迎你!')
#3.输出ASCII码字符
print('b')
print(chr(98)) #chr() 转换成ASCII字符
#4.中文编码的范围是[u4e00~u9fa5]
print(ord('北'))
print(chr(21271))
#5.输出到文件
fp = open('note.txt','w') #打开文件 W
print('北京欢迎你',file= fp) #将内容输出来到文件
fp.close #关闭文件
#6.修改结束符
print('北京',end='-->')
print('欢迎你') # 北京-->欢迎你
#7.使用连接符
print('北京'+'欢迎你') #北京欢迎你3.input()语法格式(熟练)
x = input('提示文字')
#接收到的都是字符串类型num = eval(input('请输入数字:'))
# num = int(input('请输入数字:'))
print('输入的数字是:',num)4.注释(掌握)
# coding=utf-8 中文文档注释
# 单行注释
''' / """ 多行注释
5.赋值语句(掌握)
n = 'AAA'
a,b,c=10,20,30
A=B=C=1006.语句超长换行在结尾加 \(掌握)
A1.实战:输出"人生苦短,我用Python"
需求:使用print()函数将"人生"人生苦短,我用Python" 输出到文本文件 text.txt 中.
# coding=gbk #处理文件乱码
fp = open('text.txt','w') #打开文件
print("人生苦短,我用Python",file=fp) #输出到文件
fp.close() #关闭文件
A2.实战:输出个人自我介绍
需求:使用input() 函数从键盘输入姓名,年龄,座右铭,并使用 print() 函数输出到控制台
# coding=utf-8
姓名 = input("请输入姓名:")
年龄 = input("请输入年龄:")
座右铭 = input('请输入座右铭:')
print('-'*10+'自我介绍'+'-'*10)
print('姓名:'+姓名,'年龄:'+年龄,'座右铭:'+座右铭,sep='\n')
二.数据类型与运算符
1.保留字 (35个)(掌握)
import keyword
print(len(keyword.kwlist))
print(keyword.kwlist)
2.标识符(掌握)
3.变量与常量(理解)
type() id() isinstance(a,int) 判断类型
# type() 类型查看
luck_number = 8
my_name = '小明'
print('luck_number:',type(luck_number))
print('my_name:',type(my_name))
# id() 多变量指向同一内存
no = number = 1024
print(no,number)
print(id(no),id(number))
pi = 3.14159 #定义变量
PI = 3.14159 #定义常量4.数值类型--不可变类型 (掌握)
int（整型）、float（浮点型）、bool（布尔型）、complex（复数）
num = 987
num1 = 0b1010101
num2 = 0o7654321
num3 = 0xfed
print(num,num1,num2,num3) #987 85 2054353 4077
round(浮点数,保留小数位)
a = 10.0 #小数
b = 1.99e2 #指数
x = 123 + 456j #复数
print('实数部分:',x.real)
print('虚数部分:',x.imag)
print(bool(18)) 5.字符串类型--不可变类型--有序类型(掌握)
定义
转义
索引
切片
# 0123456789
s = 'HELLOWORLD'
# 10987654321
print(s[0],s[-10]) # H H
print(s[2:7]) # LLOWO 不含7
print(s[-8:-3]) # LLOWO 不含-3常用操作 + * in
6.类型转换(掌握)
7.算数运算符(掌握)
8.赋值运算符(理解)
9.比较运行符(掌握)
10.逻辑运算符(掌握)
优先级: not and or
11.位运算符(了解)
12.运算符优先级(掌握)
B1.实战:从键盘获取一个4位整数,分别输出个位,十位,百位,千位上的数字
需求:可以使用eval()函数或int()函数将从键盘获取的数字串转成int类型,通过整除和取余操作分别获取数字.
num = eval(input('请输入一个4位整数:'))
print('个位:',num%10)
print('十位:',num//10%10)
print('百位:',num//100%10)
print('千位:',num//1000)
num = input('请输入一个4位整数:')
print('个位:',num[3])
print('十位:',num[2])
print('百位:',num[1])
print('千位:',num[0])B2.实战:根据父母身高预测儿子的身高
需求:从键盘输入父母的身高,并使用 eval() 或 float() 转换输入的数据类型.
计算公式: 儿子的身高 = (父亲身高 + 母亲身高) * 0.54
x = float(input('请输入父亲身高:'))
y = eval(input('请输入母亲身高:'))
print('预测儿子的身高:',round((x+y)*0.54,2))三.程序的流程控制
1.程序的描述方式(了解)
2.程序的组织结构(了解)
3.选择结构(掌握)
| if : |
| if :– else: |
| if :– elif : – else : |
1.单分支结构
if 表达式 :判断为偶数: if n % 2: .... 未偶数 if not n % 2:
判断为空字符串: if x: 未空 if not x:
使用 if 语句时,只有一句代码块,可以写在帽号后面: if a > b : max=a
2.双分支结构
if 表达式 :
语句块
else:
语句块使用条件表达式进行简化: 条件成立值 if 条件 else 条件不成立值
3.多分支结构
if 表达式 :
语句块
elif 表达式 :
语句块
elif 表达式 :
语句块
elif 表达式 :
语句块
else :
语句块4.嵌套
if 表达式 :
if 表达式 :
语句块
else:
语句块
else:
语句块5.模式匹配
4.循环结构(掌握)
1.for
for i in 'hello':
print(i)
for number in range(1, 6):
print(number)
else:
print('正常结束')2.while
a = input('今天要上课吗?y/n:') #初始化变量
while a == 'y': #条件判断
print('好好学习,天天向上') #语句块
a = input('今天要上课吗?y/n:')#改变变量# 1...100累加和
sum = 0
i = 1
while i<=100:
sum+=i
i+=1
else:
print(sum)3.嵌套
#1
for i in range(3):
for j in range(4):
print('*',end='')
print()
#2
for i in range(6):
for j in range(i):
print('*',end='')
print()
#3
for i in range(5,0,-1):
for j in range(i):
print('*',end='')
print()
#4
for i in range(1,6):
for j in range(1,6-i):
print(' ',end='')
print('*'*(i*2-1))
#5
n = eval(input('请输入奇数:'))
while n%2 == 0:
print(n)
n = eval(input('请输入奇数:'))
else:
for i in range(1,n,2):
print(' '*((n-i)//2),end='')
print('*'*i)
else:
for i in range(n,0,-2):
print(' '*((n-i)//2),end='')
print('*'*i)4.break跳出当前循环
for i in 'hello':
if i == 'e':
break #后面的代码不会执行
print(i)
else:
print('完成') #break 跳出后不会执行5.continue跳过后面语句,进行下次循环
for i in 'hello':
if i == 'e':
continue #只跳过当前代码进入下次循环
print(i)
else:
print('完成') i = 1
while i<10:
if i == 5:
i+=1 #改变变量
continue #一定要放在变量增减后,防止死循环
print(i)
i+=16.空语句 pass
C1.实战:输入一个年份,判断是否是闰年
需求:从键盘获取一个四位数的整数年份,判断其是否是闰年.
闰年的判断条件为:能被4整除但不能被100整除,或者能被400整除.
y = eval(input('请输入4位整数的年份:'))
if y%4 == 0 and y%100 != 0 or y%400 ==0 :
print(f'{y}是闰年')
else:
print(f'{y}是平年') C2.实战:模拟 10086 查询功能
需求:输入1,显示当前余额 ; 输入2.显示当前的剩余流量,单位为G;
输入3.显示当前剩余通话,单位为分钟; 输入0,退出自助查询系统
answer = 'y'
while answer == 'y':
num = eval(input('''
---欢迎使用 10086 自助查询功能---
显示当前余额请,输入1:
显示当前的剩余流量,输入2:
显示当前剩余通话,输入3:
退出自助查询系统,输入0:
请输入序号:'''))
match num:
case 1:
print('当前余额:99')
case 2:
print('当前的剩余流量 5 G')
case 3:
print('当前剩余通话 100 分钟')
case 0:
print('已退出系统')
break
case _:
print('输入错误!')
answer= input('是否继续操作?y/n:')
else:
print('谢谢使用.')
answer = 'y'
while answer == 'y':
print('---欢迎使用 10086 自助查询功能---')
print('1.显示当前余额请')
print('2.显示当前的剩余流量')
print('3.显示当前剩余通话')
print('0.退出自助查询系统')
num = eval(input('请输入序号:'))
if num == 1:
print('当前余额:99')
elif num == 2:
print('当前的剩余流量 5 G')
elif num == 3:
print('当前剩余通话 100 分钟')
elif num == 0:
print('已退出系统')
break
else:
print('输入错误!')
answer= input('继续操作请按y或按任意键退出:')
else:
print('谢谢使用.')
C3.实战:使用嵌套循环输出九九乘法表
需求:使用嵌套循环输出九九乘法表,内层循环与外层循环的关系,输出的数据个数与行数相同,
即第一行输出一个,1*1=1,第二行输出两个 1*2=2 2*2=4依次类推.
for i in range(10):
for j in range(1,i+1):
print(f'{j} * {i} = {i*j}\t',end='')
print()
C4.实战:猜数游戏
需求:随机生成一个1~100之间的整数,然后用户循环猜之个数,对于用户的输入,
可以提示"大了","小了",直到猜准确为止,输出用户的猜测次数.
import random
r = random.randrange(1,101) #生成1~100随机数
#r = random.randint(1,100)
cou = 0 #计数初始化
san = 'y' #变量初始化
while san == 'y':
n = eval(input('请输入一个整数猜大小:')) #输入数
cou += 1
if n == r:
print(f'你猜对了,共猜测{cou}次')
break
elif n > r:
print('你猜大了')
elif n < r:
print('你猜小了')
else:
print('输入错误')
san = input('继续请输入小写 y ,退出按任意键:') #用于主动退出randrange 函数：
语法：random.randrange(start, stop[, step])。
特点：从指定的范围中随机选择一个整数，但不包括上限stop的值。例如randrange(0, 5)只会随机返回 0、1、2、3、4 中的一个值。
可以指定步长step，实现按一定间隔随机取值。
randint 函数：
语法：random.randint(a, b)。
特点：随机返回一个整数N，满足a <= N <= b，即包含下限a和上限b的值。例如randint(0, 5)会随机返回 0、1、2、3、4、5 中的一个值。四.组合数据类型
1.序列与索引(了解)
s = 'helloworld'
for i in range(0,len(s)):
print(i,s[i])
for i in range(-10,0):
print(i,s[i])
0 h
1 e
2 l
3 l
4 o
5 w
6 o
7 r
8 l
9 d
-10 h
-9 e
-8 l
-7 l
-6 o
-5 w
-4 o
-3 r
-2 l
-1 d
序列[默认0 : 默认N-1 : 默认 1]
序列[ : : -1] 倒序输出
2.序列相关操作(掌握)
1.相乘操作 *
2.相连操作 +
3.常用操作
不带点的是内置函数,带点的是方法
.index(x) 找不到会报错
3.列表(掌握) 可变类型 有序类型
1.列表基本操作 创建,删除,遍历
三种方式遍历列表
1.for 循环
2.使用 循环 + 索引
3.使用 enumerate
lst= ['hello','world','python','php']
for item in lst:
print(item)
for i in range(len(lst)):
print(lst[i])
for index, item in enumerate(lst,2):
print( index, item ) # 这里的index 是序号不是索引2.列表的相关操作
变量名.extend(数据) 列表结尾追加数据【追加多个数据】 变量名.extend(['唐僧','白龙马'])
lst= ['hello','world','python','php']
print('原始\n',lst)
lst.append('c++') #在最后添加
print('在最后添加C++\n',lst) #['hello', 'world', 'python', 'php', 'c++']
lst.insert(0,'js') #在直定下标位添加,超标后添加到最后
print('在直定下标0位添加js\n',lst) #['js', 'hello', 'world', 'python', 'php', 'c++']
#lst.clear() #清空列表
#print(lst) #[]
lst.pop() #使用下标号清除指定数据,默认为最后一个
print('清除指定数据,默认为最后一个\n',lst) #['js', 'hello', 'world', 'python', 'php']
lst.remove('hello') #通过指定值清除,如果不存在会报错
print('清除指定值 hello\n',lst) #['js', 'world', 'python', 'php']
lst.reverse() #倒序显示
print('倒序显示\n',lst)
new_lst = lst.copy() #复制一个值相同,但内存地址不同列表
print('复制一个值相同,但内存地址不同\n',id(new_lst),id(lst))原始
['hello', 'world', 'python', 'php']
在最后添加C++
['hello', 'world', 'python', 'php', 'c++']
在直定下标0位添加js
['js', 'hello', 'world', 'python', 'php', 'c++']
清除指定数据,默认为最后一个
['js', 'hello', 'world', 'python', 'php']
清除指定值 hello
['js', 'world', 'python', 'php']
倒序显示
['php', 'python', 'world', 'js']
复制一个值相同,但内存地址不同
2249316943616 2249314195840lst = [4,56,3,78,40,56,89]
print('原列表:',lst) #原列表: [4, 56, 3, 78, 40, 56, 89]
lst.sort()
print('升序,从小到大:',lst) #升序,从小到大: [3, 4, 40, 56, 56, 78, 89]
lst.sort(reverse=True)
print('降序,从大到小:',lst) #降序,从大到小: [89, 78, 56, 56, 40, 4, 3]
print('----------字母排序---------------------')
lst2 = ['ba','Ap','ca','Or']
print('原列表:',lst2) #原列表: ['ba', 'Ap', 'ca', 'Or']
lst2.sort()
print('升序,先大写,在小写:',lst2) #升序,先大写,在小写: ['Ap', 'Or', 'ba', 'ca']
lst2.sort(reverse=True)
print('降序,先小写,在大写:',lst2) #降序,先小写,在大写: ['ca', 'ba', 'Or', 'Ap']
lst2.sort(key=str.lower)
print('升序,忽略大小写:',lst2) #升序,忽略大小写: ['Ap', 'ba', 'ca', 'Or']
print('----------sorted(列表名)---------------------')
print('默认升序:',sorted(lst)) #[3, 4, 40, 56, 56, 78, 89]
print('降序:',sorted(lst,reverse=True)) #[89, 78, 56, 56, 40, 4, 3]
print('忽略大小写升序:',sorted(lst2,key=str.lower)) #忽略大小写升序: ['Ap', 'ba', 'ca', 'Or']3.列表元素的修改操作 下标
没有方法,只有通过下标
个人理解: 先删除指定下标值, 从最小下标位置开始添加新值
lst= ['hello','world','python','php']
print('原始\n',lst)
lst[1] = 'js' #清除下标值,并添加指定值
print(lst) #['hello', 'js', 'python', 'php']
lst[1:3] = ['C','C++','JAVA'] #清除下标值,并添加指定值
#可以超过下标的个数
print(lst) #['hello', 'C', 'C++', 'JAVA', 'php']
lst[1:3] = [] #只清除下标指定值
print(lst) #['hello', 'JAVA', 'php']4.列表生成式 与 二维表
# 生成 1~10 列表
lst = [item for item in range(1,11)]
print(lst) #[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# 生成 1~10 列表,相乘
lst = [item * item for item in range(1,11)]
print(lst) #[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
#生成 10个,1到100的随机数
import random
lst = [ random.randint(1,100) for _ in range(10)]
print(lst) #[20, 21, 35, 91, 85, 56, 83, 13, 53, 62]
#添加条件 i%2==0
lst = [ i for i in range(10) if i%2==0 ]
print(lst) #[0, 2, 4, 6, 8]
# 创建二维列表
lst = [
['城市','环比','同比'],
['北京',102,103],
['上海',104,504],
['深圳',100,39]
]
print(lst)
#[['城市', '环比', '同比'], ['北京', 102, 103], ['上海', 104, 504], ['深圳', 100, 39]]
# 遍历二维列表 双层 for 循环
for row in lst: #行
for item in row: #列
print(item,end='\t')
print() #换行
'''
城市 环比 同比
北京 102 103
上海 104 504
深圳 100 39
'''
# 列表生成式生成一个 4行 5列 二维列表
#lst2 = [ [] for i in range(4) ]
lst2 = [ [ j for j in range(5) ] for i in range(4) ]
print(lst2)
#[[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]
for i in lst2:
for j in i:
print(j,end='\t')
print()
'''
0 1 2 3 4
0 1 2 3 4
0 1 2 3 4
0 1 2 3 4
'''4.元组(掌握) 不可变类型 有序类型
没有增,删,改,操作
与列表有相同的序列相关操作
访问与列表相同,都是通过下标访问
遍历方式与列表相同
1.创建与序列相关操作
# 小括号创建元组
t = ('hello',[10,20,30],'python','world')
print(t)
#('hello', [10, 20, 30], 'python', 'world')
# 使用内置函数 tuple()
t = tuple('hello world')
print(t)
#('h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd')
# 序列相关操作
t = tuple([10,20,20,40])
print(t) #(10, 20, 20, 40)
print('10在元组中是否存在:',(10 in t)) #10在元组中是否存在: True
print('10在元组是不存在:',(10 not in t))#10在元组是不存在: False
print('最大值:',max(t)) #最大值: 40
print('最小值:',min(t)) #最小值: 10
print('len:',len(t)) #len: 4
print('t.index:',t.index(20))#t.index: 1 查找下标
print('t.count:',t.count(20))#t.count: 2 统计
# 只有一个元素
t = (10) # 这是一个 int 类型
t2 = (10,) # 这是一个 元组
print(t,type(t),t2,type(t2))
#10 <class 'int'> (10,) <class 'tuple'>2.访问与3种遍历
t = ('python','hello','world')
#根据索引访问元组
print(t[0])
#python
t2 = t[0:3:2] #元组支持切片操作
print(t2)
#('python', 'world')
#元组遍历
for item in t:
print(item)
# for + range() + len()
for i in range(len(t)):
print(t[i])
# 使用 enumerate()
for index,item in enumerate(t):#index 是序号可指定,不是下标
print(index,item)3.元组生成式
得到的是一个生成式对象,需要使用 tuple() 转换成元组,才能像列表一样操作
得到的是一个生成式对象, 使用 __next__() 每次取一个,按顺序从第一个开始取,超标会报错
t = ( i for i in range(1,4) )
print(t)
#得到的是一个生成式对象,没有显示值
#<generator object <genexpr> at 0x0000025317F0C700>
#需要 tuple() 转成元组
t = tuple(t)
print(t)
#(1, 2, 3)
# 遍历
for item in t:
print(item)
# 使用 __next__() 遍历
# 在转换成元组前使用
# 得到的是一个生成式对象,没有显示值 时
t2 = ( i for i in range(1,4) )
print(t2)
#<generator object <genexpr> at 0x000001F6301CC7C0>
print(t2.__next__()) #显示第一个
print(t2.__next__()) #显示第二个
print(t2.__next__()) #显示第三个
#print(t2.__next__()) #显示第4个 ,没有会报错
t2 = tuple(t2)
print(t2) #__next__() 元组被取空了
#()4.元组与列表的区别
5.字典(掌握) 可变 无序
1.创建与序列相关操作
{ 键 : 值, ..... }
键:
1.不可重复,后面的会覆盖前面的
2.只能使用不可变类型做键
# 1)创建字典
d = {10:'cat',20:'dog',30:'pet',20:'zoo'}
print(d)
#{10: 'cat', 20: 'zoo', 30: 'pet'}
# 2)zip()
# zip() 一一对应,没对应的删除
lst1 = [10,20,30,40]
lst2 = ['cat','dog','pet','zoo','car']
zip_obj = zip(lst1,lst2)
print(zip_obj) #得到一个对象 <zip object at 0x0000018B3A281580>
# 只能转一次
#print(list(zip_obj)) #转列表 [(10, 'cat'), (20, 'dog'), (30, 'pet'), (40, 'zoo')]
#print(tuple(zip_obj)) #转元组 ((10, 'cat'), (20, 'dog'), (30, 'pet'), (40, 'zoo'))
print(dict(zip_obj)) #转字典 {10: 'cat', 20: 'dog', 30: 'pet', 40: 'zoo'}
# 3)使用参数创建
d = dict(cat= 10,dog='aa') # 键不能加引起号 '
print(d) #{'cat': 10, 'dog': 'aa'}
# 不变类型当键 , 列表不能当键
t = (10,20,30)
print({t:'cat'}) #{(10, 20, 30): 'cat'}# 序列相关操作
d = {10:'cat',20:'dog',30:'pet',20:'zoo'}
print(len(d)) #3
print(max(d)) #30
print(min(d)) #10
# 删了
del d
#print(d)
2.访问与2种遍历
# d[key] 与 d.get()区别:
# 第一种,键不存在会报错
# 第二种,键不存在得到 None 或 指定的默认值
# 访问与遍历
d = {'hello':10,'world':20,'python':30}
#访问取值
print(d['hello']) #1)取值 10 ,键不存在会报错
print(d.get('world'))#2)取值 20 ,键不存在得到 None
#区别:
# 第一种,键不存在会报错
#print(d['hellooo'])
# 第二种,键不存在得到 None,或 指定默认值
print(d.get('worldd','不存在')) #不存在
#遍历
for itme in d.items():
print(itme) # key = value 组成的元组
# ('hello', 10)
# ('world', 20)
# ('python', 30)
# 分别获取 key value
for key,value in d.items():
print(key,'---->',value)
# hello ----> 10
# world ----> 20
# python ----> 303.字典的相关操作
d.items()
popitem() 方法用于随机地移除并返回一个键值对（key-value pair）。
需要注意的是，在 Python 3.7 之前，popitem() 方法移除的键值对是任意的；
但从 Python 3.7 开始，它会按照后进先出（LIFO）的顺序移除并返回键值对，
这意味着最后插入的键值对会首先被移除
# 字典的相关方法
d = {1001:'李梅',1002:'王华',1003:'张峰'}
print(d)
# 添加元素
d[1004] = '张丽丽'
print(d) #{1001: '李梅', 1002: '王华', 1003: '张峰', 1004: '张丽丽'}
#获取所有的 key 或 value ,
print(d.keys()) #dict_keys([1001, 1002, 1003, 1004])
print(d.values()) #dict_values(['李梅', '王华', '张峰', '张丽丽'])
#转换成列表或元组
print(list(d.keys())) #[1001, 1002, 1003, 1004]
print(tuple(d.keys())) #(1001, 1002, 1003, 1004)
print(list(d.items())) #[(1001, '李梅'), (1002, '王华'), (1003, '张峰'), (1004, '张丽丽')]
#删除元素
print(d.pop(1001)) #李梅 先取出值,在把键值对删除
print(d) #{1002: '王华', 1003: '张峰', 1004: '张丽丽'}
print(d.pop(1008,'不存在'))# 删除的值不存在时,返回默认值
#print(d.pop()) #键不能为空,列表会默认是最后一个,字典无序所以会报错
#随机删除元素
print(d.popitem()) #(1004, '张丽丽') 运行好多次删除的都是这个
'''
popitem() 方法用于随机地移除并返回一个键值对（key-value pair）。
需要注意的是，在 Python 3.7 之前，popitem() 方法移除的键值对是任意的；
但从 Python 3.7 开始，它会按照后进先出（LIFO）的顺序移除并返回键值对，
这意味着最后插入的键值对会首先被移除。
'''
#清空元素
d.clear()
print(d) #{}
#python 中一切皆对象,每个对象都有一个布尔值
print(bool(d)) #False4.字典生成式
一定要记得带 : 不带创建就是集合,而不是字典
import random
d = { itme : random.randint(1,100) for itme in range(4) }
print(d)
#{0: 31, 1: 75, 2: 89, 3: 89}
lst = [1001,1002,1003]
lst2 = ['陈','王','李']
# d = {itme for itme in zip(lst,lst2)}
# print(d)
# #{(1003, '李'), (1002, '王'), (1001, '陈')}
# 上面是集合
d = {key : value for key,value in zip(lst,lst2)}
print(d)
#{1001: '陈', 1002: '王', 1003: '李'}6.集合(掌握) 可变 ,无序
1.创建与删除,序列相关操作
# 1)创建
s = {10,20,30,40}
print(s) #{40, 10, 20, 30}
# 集合只能存储不可变数据类型
#s = {[10,20],[30,40]} #TypeError: unhashable type: 'list'
# 2) set()
s = set()
print(s,type(s)) #set() <class 'set'>
s = set('helloworld')
print(s) #无序,去重
#{'o', 'l', 'h', 'e', 'r', 'd', 'w'}
s2 = set([10,20,30])
print(s2) #{10, 20, 30}
s3 = set(range(1,10))
print(s3) #{1, 2, 3, 4, 5, 6, 7, 8, 9}
# 序列相关操作
print(len(s3)) #9
print(max(s3)) #9
print(min(s3)) #1
# in not in
print('9在集合中存在吗',(9 in s3)) #9在集合中存在吗 True
print('9在集合中不存在吗',(9 not in s3)) #9在集合中不存在吗 False
# del
del s3
print(s3)2.集合的操作符
A = {10,20,30,40,50}
B = {30,50,88,76,28}
# 交
print( A & B ) #{50, 30}
# 并
print( A | B ) #{40, 10, 76, 50, 20, 88, 28, 30}
# 差
print( A - B ) #{40, 10, 20}
# 补
print( A ^ B ) #{10, 20, 88, 40, 76, 28}3.集合的相关操作,遍历,推导式
追加数据序列：
集合名.update(数据序列) # 数据序列：列表，字符串，元组
删除数据：
集合名.remove(数据) # 如果数据不存在，报错
集合名.discard(数据) # 如果数据不存在，不报错
s = {10,20,30}
# 添加
s.add(100) # 如果已存在,会先添加,在去重
print(s) #{100, 10, 20, 30}
# 删除
s.remove(20) #如果没有会报错
print(s) #{100, 10, 30}
# 清空
s.clear()
print(s) #set()
# 遍历
s = {10,20,30}
for item in s:
print(item)
# 10
# 20
# 30
for index,item in enumerate(s,1):
print(index,'--->',item)
# 1 ---> 10
# 2 ---> 20
# 3 ---> 30
# 推导式
s = { i for i in range(1,10)} # 使用 : 就是字典
print(s) #{1, 2, 3, 4, 5, 6, 7, 8, 9}
s = { i for i in range(1,10) if i%2==0 } # 使用 : 就是字典
print(s) #{8, 2, 4, 6}7.组合数据类型区别
8.3.11新特性
# 结构模型匹配 相当于多重if中的else
date = eval(input('请输入要匹配的数据:'))
match date:
case {'name':'ysj','age':20}:
print('字典')
case [10,20,30]:
print('列表')
case (10,20,30):
print('元组')
case _:
print('相当于多重if中的else')# 字典合并 | 相当于 .update(数据序列)
d1 = {'a':10,'b':20}
d2 = {'c':30,'d':40,'e':50}
# d1.update(d2)
# print(d1) #{'a': 10, 'b': 20, 'c': 30, 'd': 40, 'e': 50}
# 同上
d1 = d1 | d2
print(d1) #{'a': 10, 'b': 20, 'c': 30, 'd': 40, 'e': 50}# 同步迭代
#fruits = {'apple','orange','pear','grape'} #字典是无序随机的,产生的结果也是
fruits = ['apple','orange','pear','grape'] #改成列表将同步输出
counts = [10,3,4,5]
for f ,c in zip(fruits,counts):
match f,c:
case 'apple',10:
print('10个苹果')
case 'orange',3:
print('3个桔子')
case 'pear',4:
print('4个梨')
case 'grape',5:
print('5串葡萄')D1.实战: "千年虫" 是什么虫
需求:已知一个列表中存储的员工的出生年份[88,89,90,98,00,99],
由于时间比较久,出生的年份均为2位整数,现需要2位年份前加19,如果年份是00,将需要加上200
lst = [88,89,90,98,00,99]
print(lst)
lst2 = []
for i in lst:
if i > 0:
k = '19' + str(i)
k = int(k)
lst2.append(k)
elif i == 0:
k = '200' + str(i)
k = int(k)
lst2.append(k)
else:
print(i)
print(lst2) #[1988, 1989, 1990, 1998, 2000, 1999]D2.实战:模拟京东购物流程
需求:从键盘录入5个商品信息(1001,手机)添加到商品列表,展示商品信息,提示用户选择商品,
用户选中的商品添加到购物车中(购物车中的商品要逆序),用户选中的商品不存在需要有相应提示,
当用户输入 "q" 时循环结束,显示购物车中的商品.
# 创建空列表,用于存储入库的商品信息
lst = []
for i in range(5):
goods = input('请输入商品的编号和商品的名称进行商品入库,每次只能输入一件商品:')
lst.append(goods)
print(lst)
#
for item in lst:
print(item)
# 创建一个空列表,用于存储购物车中的商品
cart = []
while True:
flag = False #代表没有商品的情况
num = input('请输入要购买的商品编号:')
# 遍历商品列表,查询一下要购买的商品是否存在
for item in lst:
if num == item[0:4]: #切片操作,从商品列表切出编号
flag = True #代表商品已找到
cart.append(item) #添加到购物车中
print('商品已成功添加到购物车.')
break #退出当前 for 循环
if not flag and num != 'q': # not flag 等价于 flag == False
print('商品不存在.')
if num == 'q':
break # 退出的才是 while 循环
print('-'*50)
print('您购物车里忆选择的商品为:')
cart.reverse()
for item in cart:
print(item)请输入商品的编号和商品的名称进行商品入库,每次只能输入一件商品:1001手机
请输入商品的编号和商品的名称进行商品入库,每次只能输入一件商品:1002水杯
请输入商品的编号和商品的名称进行商品入库,每次只能输入一件商品:1003电脑
请输入商品的编号和商品的名称进行商品入库,每次只能输入一件商品:1004猫粮
请输入商品的编号和商品的名称进行商品入库,每次只能输入一件商品:1005猫砂
['1001手机', '1002水杯', '1003电脑', '1004猫粮', '1005猫砂']
1001手机
1002水杯
1003电脑
1004猫粮
1005猫砂
请输入要购买的商品编号:1001
商品已成功添加到购物车.
请输入要购买的商品编号:1003
商品已成功添加到购物车.
请输入要购买的商品编号:1008
商品不存在.
请输入要购买的商品编号:1004
商品已成功添加到购物车.
请输入要购买的商品编号:q
--------------------------------------------------
您购物车里忆选择的商品为:
1004猫粮
1003电脑
1001手机D3.实战:模拟12306火车票订票流程
需求:假设北京到天津有以下4个车次可供选择,用户选择所要购买的车次,进行购票进站.
# 创建字典用于存储车票信息
# 使用车次作 key,使用其它信息作 values
dict_ticket = {
'G1569':['北京南-天津南','18:06','18:39','00:33'],
'G1567':['北京南-天津南','18:15','18:49','00:34'],
'G8917':['北京南-天津西','18:20','19:19','00:50'],
'G203':['北京南-天津南','18:35','19:09','00:34']
}
print('车次 出发站-到达站 出发时间 到达时间 历时时长')
# 遍历字典中元素
for key in dict_ticket.keys():
print(key,end=' ') # 为什么不换行,因为车次与车次的祥细信息在一行显示
#G1569 G1567 G8917 G203
# 根据 key 获取出来的值是一个列表
for item in dict_ticket.get(key): #根据 key 获取值
print(item,end='\t\t')
#换行
print()
# 输入用户的购票车次
train_no = input('请输入要购买的车次:')
# 根据 key 获取值
info = dict_ticket.get(train_no,'车次不存在') #info 是一个列表类型
# 判断车次是否存在
if info != '车次不存在':
person = input('请输入乘车人,如果是多位乘车人使用逗号分隔:')
# 获取车次的出发站-到达站,
s = info[0] + ' ' + info[1] + '开'
print('您已购买' + train_no + ' ' + s + ',请' + person + '尽快换取纸制车票.[铁路客服]' )
else:
print('对不起,选择的车次可能不存在.')
车次 出发站-到达站 出发时间 到达时间 历时时长
G1569 北京南-天津南 18:06 18:39 00:33
G1567 北京南-天津南 18:15 18:49 00:34
G8917 北京南-天津西 18:20 19:19 00:50
G203 北京南-天津南 18:35 19:09 00:34
请输入要购买的车次:G1567
请输入乘车人,如果是多位乘车人使用逗号分隔:李刚,王五
您已购买G1567 北京南-天津南 18:15开,请李刚,王五尽快换取纸制车票.[铁路客服]D4.实战:模拟手机通讯录
需求:从键盘录入 5 位好友的姓名和电话,由于通讯录是无序的所以可以使用集合来实现.
se = set()
print(type(se))
# 添加好友姓名与手机号
for i in range(1,6):
n = input(f'请输入第{i}位好友的姓名与手机号码:')
se.add(n)
# 遍历集合
for item in se:
print(item)<class 'set'>
请输入第1位好友的姓名与手机号码:张小18600987654
请输入第2位好友的姓名与手机号码:陈梅18754698758
请输入第3位好友的姓名与手机号码:王一一13698752647
请输入第4位好友的姓名与手机号码:方乐乐18965489756
请输入第5位好友的姓名与手机号码:白月光13987532458
白月光13987532458
王一一13698752647
方乐乐18965489756
陈梅18754698758
张小18600987654五.字符串及正则表达式 不可变,有序类型
1.字符串的常用操作(掌握)
s1 = 'HelloWorld'
# 全小写
new_s2 = s1.lower()
print(new_s2) #helloworld
# 全大写
new_s3 = s1.upper()
print(new_s3) #HELLOWORLD
# 分隔
e_mail = 'ysj@126.com'
lst = e_mail.split('@')
print('邮箱名:',lst[0],'邮箱域名',lst[1])
#邮箱名: ysj 邮箱域名 126.com
# 计数
print(s1.count('o')) #2
# 检索操作
print(s1.find('o')) #4 #第一个下标4
print(s1.find('p')) #-1 #没找到
print(s1.index('o')) #4 #第一个下标4
#print(s1.index('p')) #ValueError: substring not found #没找到
# 判断前后缀
print(s1.startswith('H')) #True
print('demo.py'.endswith('.py')) #True
s1 = 'HelloWorld'
# 替换
new_s1 = s1.replace('o','你好',1)
print(new_s1) #Hell你好World
# 指定宽度,在宽度内居中
print(s1.center(20)) # HelloWorld
print(s1.center(20,'*')) #*****HelloWorld*****
# 去除空格
s1 = ' Hello World '
print(s1.strip()) #左右Hello World
print(s1.lstrip()) #左Hello World
print(s1.rstrip()) #右 Hello World
# 去掉指定字符
s3 = 'dl-Helloworld'
print(s3.strip('ld')) # 与顺序无关,按单个字符去除
#-Hellowor
print(s3.lstrip('ld'))
#-Helloworld
print(s3.rstrip('ld'))
#dl-Hellowor2.格式化字符串的三种方式(熟练)
# 1) %
name = '马冬梅'
age = 18
score = 98.5
print('姓名:%s,年龄:%d,分数:%f' % (name,age,score))
#姓名:马冬梅,年龄:18,分数:98.500000
print('姓名:%s,年龄:%d,分数:%.2f' % (name,age,score))
#姓名:马冬梅,年龄:18,分数:98.50
# 2) f-string
print(f'姓名:{name},年龄:{age},分数:{score}')
#姓名:马冬梅,年龄:18,分数:98.5
print(f'姓名:{name},年龄:{age},分数:{score:.2f}')
#姓名:马冬梅,年龄:18,分数:98.50 # 不写f 是指数形式
# 3) format
print('姓名:{0},年龄:{1},分数:{2}'.format(name,age,score))
#姓名:马冬梅,年龄:18,分数:98.5
#分数:{2:.2f} 分数:98.50
s = 'helloworld'
print('{0:*<20}'.format(s))
# *号填充 <左对齐 宽度20
#helloworld**********
print('{0:*>20}'.format(s))
#**********helloworld
print('{0:*^20}'.format(s))
#*****helloworld*****
#居中
print(s.center(20,'*'))
#*****helloworld*****
# 千位分隔符(只适用于整数与浮点数)
print('{0:,}'.format(987654321)) #987,654,321
print('{0:,}'.format(987654321.7865)) #987,654,321.7865
# 浮点数小数精度
print('{0:.2f}'.format(3.1419826)) #3.14
# 字符串类型,表示最大显示长度
print('{0:.5}'.format('helloworld')) #hello
# 整数类型
a = 425
print('2进制:{0:b},8进制:{0:o},10进制{0:d},16进制{0:x}'.format(a))
#2进制:110101001,8进制:651,10进制425,16进制1a9
# 浮点数类型
b = 3.1415926
print('{0:.2f},{0:.2E},{0:.2e},{0:.2%}'.format(b))
#3.14,3.14E+00,3.14e+00,314.16%3.字符串的编码与解码(掌握)
s = '伟大的中国梦'
# 编码 str --> bytes
s_code = s.encode(errors='replace') # 默认utf-8,中文占3个字节,英文占1个字节
print(s_code,len(s_code))
#b'\xe4\xbc\x9f\xe5\xa4\xa7\xe7\x9a\x84\xe4\xb8\xad\xe5\x9b\xbd\xe6\xa2\xa6' 18
gbk_code = s.encode('gbk',errors='replace') #中文占2个字节,英文占1个字节
print(gbk_code,len(gbk_code))
#b'\xce\xb0\xb4\xf3\xb5\xc4\xd6\xd0\xb9\xfa\xc3\xce' 12
# 出错问题
# errors='strict' 不能转换时 报错
# errors='ignore' 不能转换时 忽略
# errors='replace' 不能转换时用 ? 代替
# 解码 bytes --> str
print(bytes.decode(gbk_code,'gbk')) #伟大的中国梦
print(bytes.decode(s_code)) #伟大的中国梦4.数据的验证方法(掌握)
# .isdigit() 只识别 10 进制阿拉伯数字
print('123'.isdigit()) #True
print('一二三'.isdigit()) #False
print('0b1010'.isdigit()) #False
print('ⅠⅡⅢ'.isdigit()) #False
print('-'*50,'.isdigit() 只识别 10 进制阿拉伯数字')
# 所有数字(不包二进制)
print('123'.isnumeric()) #True
print('一二三'.isnumeric()) #True
print('0b1010'.isnumeric()) #False
print('ⅠⅡⅢ'.isnumeric()) #True
print('壹贰叁'.isnumeric()) #True
print('-'*50,'所有数字(不包二进制)')
# 所有字符都是字母(包含中文)
print('hello你好'.isalpha()) #True
print('hello你好123'.isalpha()) #False
print('hello你好一二三'.isalpha()) #True
print('hello你好ⅠⅡⅢ'.isalpha()) #False
print('-'*50,'所有字符都是字母(包含中文)')
# 所有字符都是字母或数字(包含中文)
print('hello你好'.isalnum()) #True
print('hello你好123'.isalnum()) #True
print('hello你好一二三'.isalnum()) #True
print('hello你好ⅠⅡⅢ'.isalnum()) #True
print('-'*50,'所有字符都是字母或数字(包含中文)')
# 判断小写
print('HelloWorld'.islower()) #False
print('helloworld'.islower()) #True
print('hello你好'.islower()) #True
print('-'*50,'判断小写')
# 判断大写
print('HelloWorld'.isupper()) #False
print('HELLOWORLD'.isupper()) #True
print('HELLO你好'.isupper()) #True
print('-'*50,'判断大写')
# 中文 是大写 也是
# 首字母大写
print('Hello'.istitle()) #True
print('HelloWorld'.istitle()) #False
print('Helloworld'.istitle()) #True
print('Hello World'.istitle()) #True
print('Hello world'.istitle()) #False
print('-'*50,'首字母大写')
# 判断是否是空白字符
print('\t'.isspace()) #True
print(' '.isspace()) #True
print('\n'.isspace()) #True
print('-'*50,'判断是否是空白字符')5.数据的处理-拼接与去重(掌握)
# 拼接
# 1) +
s1 = 'hello'
s2 = 'world'
print(s1 + s2) #helloworld
# 2) join()
print(''.join([s1,s2])) #helloworld
# 使用空字符串进行拼接
print('*'.join(['hello','world','python','java']))
#hello*world*python*java
# 3) 直接拼接
print('hello''world') #helloworld
# 4) 格式化字符串拼接
print('%s%s' % (s1,s2)) #helloworld
print(f'{s1}{s2}') #helloworld
print('{0}{1}'.format(s1,s2)) #helloworlds = 'helloworldhelloworlddadfdfdeoodllffe'
# 1) 字符串拼接及 not in
new_s = ''
for item in s:
if item not in new_s:
new_s += item #拼接操作
print(new_s)
# 2) 索引 + not in
new_s2 = ''
for i in range(len(s)):
if s[i] not in new_s2:
new_s2 += s[i] #拼接操作
print(new_s2)
# 3) 通过集合去重 + 列表排序
new_s3 = set(s) #转成集合去重
lst = list(new_s3) #转成列表
print(lst)
lst.sort(key=s.index)#按字符串排序
print(lst)
print(''.join(lst)) #列表拼接成字符串6.正则表达式的使用(掌握)
在 re.match(pattern, string, flags=0)中，flags参数用于控制正则表达式的匹配方式，
它是一个可选的整数参数，有以下一些常见的标志：
re.IGNORECASE（或简写为 re.I）：使匹配对大小写不敏感。
例如，原本正则表达式匹配小写字母 a，加上这个标志后，大写字母 A 也能匹配成功。
re.MULTILINE（或简写为 re.M）：影响 ^ 和 $ 的行为，使其可以匹配每行的开头和结尾，
而不仅仅是整个字符串的开头和结尾。
re.DOTALL（或简写为 re.S）：使 . 匹配包括换行符在内的任意字符。
如果没有这个标志，. 通常不会匹配换行符。
re.VERBOSE（或简写为 re.X）：允许在正则表达式中添加注释，使正则表达式更具可读性。
在这种模式下，空白字符和注释会被忽略，除非在字符类中或者前面有反斜杠转义。
re.LOCALE（或简写为 re.L）：根据本地语言环境设置进行匹配。
不过这个标志的行为可能因平台和 Python 版本而有所不同，并且现在不太推荐使用，
因为它可能会导致不可移植的代码。
你可以通过按位或运算符（|）将这些标志组合起来使用。
例如：re.match(pattern, string, flags=re.I | re.M)。match
import re
pattern = '\d\.\d+' # 数字 点 数字N个
s = 'I study Python 3.11 every day'
match=re.match(pattern,s,re.I) # .match 从开始匹配,re.I对大小写不敏感
print(match) #None 没匹配到
s2 = '3.11 Python I study every day'
match2=re.match(pattern,s2)
print(match2) #<re.Match object; span=(0, 4), match='3.11'>
print('匹配值的起始位置:',match2.start())
print('匹配值的结束位置:',match2.end())
print('匹配区间的位置元素:',match2.span())
print('待匹配的字符串:',match2.string)
print('匹配的数据:',match2.group()) pattern = '\d\.\d+' # 数字 点 数字N个
None
<re.Match object; span=(0, 4), match='3.11'>
匹配值的起始位置: 0
匹配值的结束位置: 4
匹配区间的位置元素: (0, 4)
待匹配的字符串: 3.11 Python I study every day
匹配的数据: 3.11searth
import re
pattern = '\d\.\d+'
s = 'I study Python 3.11 every day Python 2.7.1 I love you'
match=re.search(pattern,s) # .search 匹配整个字符串
print(match) #<re.Match object; span=(15, 19), match='3.11'>
s2 = '4.10 Python I study every day'
s3 = 'I study Python every day'
match2 = re.search(pattern,s2)
match3 = re.search(pattern,s3)
print(match2) #<re.Match object; span=(0, 4), match='4.10'>
print(match3) #None
print(match.group()) #3.11
print(match2.group()) #4.10
findall
import re
pattern = '\d\.\d+'
s = 'I study Python 3.11 every day Python 2.7.1 I love you'
s2 = '4.10 Python I study every day'
s3 = 'I study Python every day'
lst=re.findall(pattern,s)
lst2 = re.findall(pattern,s2)
lst3 = re.findall(pattern,s3)
print(lst) #['3.11', '2.7']
print(lst2) #['4.10']
print(lst3) #[]sub
import re
pattern = '黑客|破解|反爬'
s = '我想学习python,想破解一些vip视频,python可以实现无底线反爬吗?'
new_s = re.sub(pattern,'xxx',s) #匹配值,替换值
print(new_s)
#我想学习python,想xxx一些vip视频,python可以实现无底线xxx吗?split
s2 = 'https://www.baidu.com/s?wd=ysj&rsv_spt=1'
pattern2 = '[?|&]'
lst = re.split(pattern2,s2)
print(lst) #['https://www.baidu.com/s', 'wd=ysj', 'rsv_spt=1']总结:
E1.实战: 判断车牌归属地
lst = ['京A8888','津B6666','吉A7766']
for item in lst:
area = item[0:1]
print(item,'归属地为:',area)E2.实战:统计字符串中出现指定字符的次数
s = 'HelloPython,HelloJava,hellophp'
word = input('请输入要统计的字符:')
print('{0}在{1}一共出现了{2}'.format(word,s,s.lower().count( word.lower() )))E3.实战:格式化输出商品的名称与单价
lst = [
['01','电风扇','美的',500],
['02','洗衣机','TCL',1000],
['03','微波炉','老板',400]
]
print('编号\t名称\t品牌\t单价')
for item in lst:
for i in item:
print(i,end='\t')
print()
print('-'*50)
# 格式化操作
for item in lst:
#item[0] = '0000' + item[0]
item[0] = '{0:0>6}'.format(item[0])
item[3] = '${0:.2f}'.format(item[3])
print('编号\t名称\t品牌\t单价')
for item in lst:
for i in item:
print(i,end='\t')
print()E4.实战:提取文本中所有图片的链接地址
import re
s = '有个链接的文本'
pattern = 'https://设置模式'
lst = re.findall(pattern,s) #查找
for item in lst:
print(item)六.异常处理
1.bug的由来及分类
2.不同异常类型的处理方式
try:
num1 = int(input('请输入一个整数:'))
num2 = int(input('请输入一个整数:'))
result = num1 / num2
#print('结果:',result)
except ZeroDivisionError: # 针多不同错误,做出不同处理
print('除数为0')
except ValueError: # 针多不同错误,做出不同处理
print('不能将字符串转成整数.')
except BaseException: # 未确定的异常
print('未知异常')
else:
print('结果2:',result) #程度正常时运行
finally:
print('程序运行结束.')
try:
gender = input('请输入你的性别:')
if gender != '男' and gender != '女':
raise Exception('性别只能是男或女') #异常信息
else:
print('您的性别是:',gender)
pass
except Exception as e: # as e 给异常取个别名
print(e) #输出异常3.异常处理机制
F1.实战:编写程序接收用户输入分数信息
try:
num = int(input('请输入分数:'))
if 0<= num <=100:
pass
else:
raise Exception('分数不正确')
except Exception as e:
print(e)
else:
print('分类为:',num)
finally:
print('程序结束.')F2.实战:编写程序实现组成三角形的判断
try:
a = int(input('请输入第一条边长:'))
b = int(input('请输入第二条边长:'))
c = int(input('请输入第三条边长:'))
if a+b > c and a + c > b and b + c > a:
print('三角形的边长为:',a,b,c)
else:
raise Exception(f'{a},{b},{c},不能构建三角形')
pass
except Exception as e:
print(e)七.函数及常用内置函数
1.函数的定义及调用
def get_sum(num): #num 形式参数
s = 0
for i in range(1,num+1):
s += i
print(f'1到{num}之间的累加和为:{s}')
# 函数调用
get_sum(10) # 实际参数
get_sum(100)
get_sum(1000)1到10之间的累加和为:55
1到100之间的累加和为:5050
1到1000之间的累加和为:500500
2.函数的参数传递
1.位置参数:实参与形参 要对应个数,对应数据类型,对应顺序要对应
2.关键字参数:指定形参与实参,对应顺序要没要求
(混合传参, 关键字传参放后面, 前面按位置传参)
3.默认值参数:默认参数带位置
(混合: 默认参数与位置参数, 默认参数放后面 )
def happy_birthday(name,age):
print('祝'+name+'生日快乐')
print(str(age)+'生日快乐')
# 调用
#happy_birthday('李') #实参与形参 要对应个数
#TypeError: happy_birthday() missing 1 required positional argument: 'age'
#happy_birthday(18,'李') #实参与形参 类型要对应,顺序要对应
#TypeError: can only concatenate str (not "int") to str
happy_birthday('李',18) #位置参数
happy_birthday(age=18,name='李') #关键字参数,没有顺序要求
#混合传参, 关键字传参要放后面
happy_birthday('李',age=18) # 混合传参, 可以
#happy_birthday(name='李',18) # 混合传参, 报错def happy_birthday(name='李',age=18): #设置默认值
print('祝'+name+'生日快乐')
print(str(age)+'生日快乐')
# 调用
happy_birthday() #不用传参
happy_birthday('陈') #位置传参
happy_birthday(age=19) #关键字传参
# 同时存在默认参数与位置参数,默认参数放后面
def fun(a,b=20): # a作为位置参数,b默认值参数
pass
def fun2(a=20,b): # 报错了,语法错误
pass
位置参数: 个数可变 元组类型 * 名子可自己取, 引用 列表 传参需要在前加 *
关键字参数: 个数可变 字典类型 ** 名子可自己取, 引用 字典 传参需要在前加 **
# 个数可变的位置参数
def fun(*para): #元组类型
print(type(para))
for item in para:
print(item)
# 调用
fun(10,20,30,40)
fun()
fun(20,30)
fun([11,22,33,44]) # 实际上传递的是一个参数
## 在调用时,参数前加 1 颗星,分别将列表进行解包
fun(*[11,22,33,44]) # 个数可变的关键字参数 --> 字典类型
def fun2(**kw_para): # kw_para自己定义的
print(type(kw_para)) #字典类型
for key,value in kw_para.items():
print(key,'-----',value)
# 调用
fun2(name='李',age=18,height=170) # 关键字参数
d = {'name':'李','age':18,'height':170}
#fun2(d) 报错
fun2(**d) ## 在调用时,参数前加 2 颗星,分别将列表进行解包3.函数的返回值
# 函数的返回值
def calc(a,b):
print(a+b)
calc(10,20) # 30
print(calc(1,2)) # None,没有return 返回None
def calc2(a,b):
s = a+b
return s
print('-'*10)
get_s = calc2(1,2)
print(get_s) # 3
get_s2 = calc2(calc2(1,2),3) #1+2+3
print(get_s2) # 6
print('-'*10)
# 返回多个值
def get_sum(num):
s = 0 # 累加和
odd_sum = 0 #奇数和
even_sum = 0 #偶数和
for i in range(1,num+1):
if i%2 != 0: #说明是奇数
odd_sum += i
else:
even_sum += i
s += i
return odd_sum,even_sum,s # 三个值
result = get_sum(10)
print(result) #(25, 30, 55)
# 解包
a,b,c = get_sum(10) #返回 3个值,元组类型
print(a,b,c) # 25 30 554.变量作用域
global s # 全局变量声明 与 赋值要分开 要先在函数外声明,
# 局部变量
def calc(a,b):
s = a+b
return s
print(calc(10,20))
#print(a,b,s) # NameError: name 'a' is not defined
print('-'*50,'局部变量')
# 全局变量 函数外
a = 100 # 全局变量
def calc2(x,y):
s = a+x+y #引用
return s
print(a)
print(calc2(10,20))
print('-'*50,'全局变量 函数外')
# 全局变量 函数内
s = 0 # print(s) 报错
def calc3(x,y):
global s # 全局变量声明 与 赋值要分开
s = 300
return s+x+y
print(s) #此时全局变量 s 还未被赋值，所以会引发错误 到上面 s = 0
print(calc3(10,20))
print(s)5.匿名函数 lambda 的使用
def calc(a,b):
return a+b
print(calc(10,20))
# 匿名函数
s = lambda a,b:a+b # s表示就是一个匿名函数
print(type(s)) #<class 'function'>
# 调用匿名函数
# 列表的正常取值操作
lst = [10,20,30,40,50]
for i in range(len(lst)):
print(lst[i])
print('-'*50)
# 有什么意义????
for i in range(len(lst)):
result = lambda x:x[i]
print(result(lst))
print('-'*50)
# 字典排序
student_scores = [
{'name':'陈','score':98},
{'name':'王','score':95},
{'name':'张','score':100},
{'name':'白','score':65}
]
# 对列表进行排序,排序的规则,是字典只的成绩
student_scores.sort(key=lambda x:x.get('score'),reverse=True) #降序
print(student_scores)6.递归
def fac(n): # n的阶乘, N!=N*(N-1)!....1!=1
if n == 1: #相当于 while 条件
return 1
else:
return n*fac(n-1) #自己调用自己 相当于 i-=i
print(fac(5))
def fun(n):
if n == 1 or n==2:
return 1
else:
return fun(n-1)+fun(n-2)
print(fun(9))
for i in range(1,10):
print(fun(i),end='\t')
print()34
1 1 2 3 5 8 13 21 347.常用的内置函数
lst = [54,56,77,4,567,34]
# 1) 排序操作
asc_lst = sorted(lst)
desc_lst= sorted(lst,reverse=True)
print('原始:',lst)
print('升序:',asc_lst)
print('降序:',desc_lst)
# 原始: [54, 56, 77, 4, 567, 34]
# 升序: [4, 34, 54, 56, 77, 567]
# 降序: [567, 77, 56, 54, 34, 4]
# 2) 反向 得到一个迭代对象
new_lst = reversed(lst)
print(type(new_lst)) #<class 'list_reverseiterator'>
print('原始:',lst)
print('反向:',list(new_lst))
# 原始: [54, 56, 77, 4, 567, 34]
# 反向: [34, 567, 4, 77, 56, 54]
# 3) zip 得到一个迭代对象
x = ['a','b','c','d']
y = [10,20,30,40,50]
zip_obj = zip(x,y)
print(type(zip_obj)) #<class 'zip'>
print(tuple(zip_obj))
#(('a', 10), ('b', 20), ('c', 30), ('d', 40))
# 4) enumerate 得到一个迭代对象
y = [10,20,30,40,50]
enum = enumerate(y,start=2)
print(type(enum)) #<class 'enumerate'>
print(tuple(enum))
((2, 10), (3, 20), (4, 30), (5, 40), (6, 50))
# 5) all
lst = [54,56,77,4,567,34]
lst2 = [10,20,'',30]
print(all(lst)) #True
print(all(lst2)) #False
# 6) any
print(any(lst)) #True
print(any(lst2)) #True
# 7) next 一次取一个
x = ['a','b','c']
y = [10,20,30]
zip_obj = zip(x,y)
print(next(zip_obj)) #('a', 10)
print(next(zip_obj)) #('b', 20)
print(next(zip_obj)) #('c', 30)
#print(next(zip_obj)) 超标报错
# 8) filter 得到一个迭代对象
def fun(num):
return num%2==1 #布尔值,True/False
#将range(10),0-9的整数,都执行一次fun操作
#将结果都存到 obj 对象中
obj = filter(fun,range(10))
print(type(obj)) #<class 'filter'>
print(list(obj)) #[1, 3, 5, 7, 9]
# 9) map 得到一个迭代对象
def upper(x):
return x.upper()
new_lst2 = ['hello','world','python']
obj2 = map(upper,new_lst2)
print(type(obj2)) #<class 'map'>
print(list(obj2)) #['HELLO', 'WORLD', 'PYTHON']
#简化遍历在编程中，map和filter主要有以下区别：
一、功能不同
map：- 主要功能是对可迭代对象中的每个元素进行特定的操作，并返回一个新的可迭代对象，其中每个元素都是原对象中对应元素经过操作后的结果。
- 例如，你有一个列表包含一些数字，使用
map可以对每个数字进行平方操作，得到一个新的列表，其中每个元素都是原列表对应数字的平方。
filter：- 用于过滤可迭代对象中的元素，根据给定的条件判断每个元素是否应该保留，返回一个新的可迭代对象，其中只包含满足条件的元素。
- 比如，对于一个包含若干整数的列表，使用
filter可以筛选出其中的偶数，得到一个只包含偶数的新列表。
二、参数和返回值
map：- 接受两个参数，第一个参数是一个函数，这个函数会被应用到可迭代对象的每个元素上；第二个参数是可迭代对象。
- 返回值是一个新的可迭代对象，通常是一个迭代器或类似列表的对象（具体取决于编程语言的实现）。
filter：- 同样接受两个参数，第一个参数是一个判断函数，用于确定元素是否满足条件；第二个参数是可迭代对象。
- 返回值也是一个新的可迭代对象，只包含满足条件的元素。
三、用法示例
以下是在 Python 中的示例：
numbers = [1, 2, 3, 4, 5]
# 使用 map 对每个元素进行平方操作
squared_numbers = list(map(lambda x: x**2, numbers))
print(squared_numbers) # 输出 [1, 4, 9, 16, 25]
# 使用 filter 筛选出偶数
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers) # 输出 [2, 4]
总之，map用于对可迭代对象中的每个元素进行特定操作，而filter用于根据条件筛选可迭代对象中的元素。
# format()
print(format(3.14,'20')) #数值 默认右对齐
print(format('hello','20')) #字符串 默认左对齐
print(format('hello','*<20'))#左对齐,宽度20,用*填充
print(format('hello','*>20'))#右对齐,宽度20,用*填充
print(format('hello','*^20'))#居中对齐,宽度20,用*填充
print(format(3.1415926,'.2f')) #3.14
print(format(20,'b'))
print(format(20,'o'))
print(format(20,'x'))
6777
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
