print()函数
print(520)
print(20.1)
print('hello word')
print(1+6)
#创建文件并在文件中输入 注意 1.所指定的盘符要存在 2.使用file=fp
fp=open('D:/text.text','a+') # a+ 如果文件不存在就创建，存在就在内容的后面继续追加
print('hellow',file=fp)
fp.close()
#不进行换行输出
print('hello,word,python')
转义字符
print('HELLO\nword')#换行
print('hello\tword')# \t 是按照字节四个字符来留空格的，如果前面的字符为四的倍数则\t会重新留出四个字符位 若前面不是四的倍数则留的位数和前面相加为四的倍数
print('helloooo\tword')#简单理解 上一条三个空格，此行四个空格
print('hello\rword')#一种覆盖
print('hello\bword')#退一个格
print('http:\\\\www.baidu.com')
print('他说:\'你好\'')
#原字符，不希望字符串中的转义字符起作用，就是用原字符，就是在字符串之前加上 r R
#注意最后一个字符不能是\可以是双的
print(r'hello\ndskjdgs')
print(chr(0b100111001011000))
print(ord('乘'))
查看保留字
#查看保留字
import keyword
print(keyword.kwlist)
变量的定义和使用
#变量的定义和使用
name='玛丽亚'
print(name)
print('标识',id(name))
print('类型',type(name))
print('值',name)
#多次赋值后，变量名指向新的空间、
name='三块'
name='撒'
print(name)
整数类型
#整数类型，可表示正数、负数、0
n1=22
n2=0
n3=-9
print(n1,type(n1))
print(n2,type(n2))
print(n3,type(n3))
#整数可用二进制、八进制、十进制、十六进制
print('十进制',10)
print('二进制',0b1111)
print('八进制',0o444)
print('十六进制',0x4444)
浮点类型
#浮点类型
a=3.145
print(a,type(a))
a1=1.1
a2=2.2
print(a1+a2)
#解决浮点数相加不准确问题 导入模块 并不是所有的浮点数相加都会出现问题
from decimal import Decimal
print(Decimal('1.1')+Decimal('2.2'))
布尔类型
#布尔类型
f1=False
f2=True
print(f1,type(f1))
#布尔值可以转成整数计算
print(f1+1)#结果为0+1=1 false表示0
print(f2+1)#结果为1+1=2 true表示1
字符串类型
#字符串类型
str1='人生苦短，我不吃饭'
print(str1,type(str1))
str2="人生苦短，我不吃饭"
print(str2,type(str2))
#三引号可以多行实现
str3="""人生苦短，
我不吃饭"""
print(str3,type(str3))
str4='''人生苦短，
我不吃饭'''
print(str4,type(str4))
运行结果：
人生苦短，我不吃饭 <class ‘str’>
人生苦短，我不吃饭 <class ‘str’>
人生苦短，
我不吃饭 <class ‘str’>
人生苦短，
我不吃饭 <class ‘str’>
数据类型转换
#数据类型转换
name='张三'
age=12
print(type(name),type(age))
print('我叫'+name+'今年'+str(age)+'岁')#str与int连接报错，解决：类型转换
print('----------------------str()将其他数据类型转换成咸str------------------------')
a=10
b=1.254
c=False
print(type(a),type(b),type(c))
print(str(a),str(b),str(c),type(str(a)),type(str(b)),type(str(c)))
print('--------int()将其他类型转换成int-------------')
a1='111'
a2=22.33
a3='10.23'
a4=True
a5='hello'
print(type(a1),type(a2),type(a3),type(a4),type(a5))
print(int(a1),type(int(a1))) #将str转换成int 字符串为数字串
print(int(a2),type(int(a2))) #float转换成int保留整数
#print(int(a3),type(int(a3))) #将str转换成int 失败 因为字符串为小数串
print(int(a4),type(int(a4)))
#print(int(a5),type(int(a5))) #将str转换成int 失败 因为字符串必须为数字串（整数）
#float函数
print('--------float()函数，把其类型转换成float类型----------')
s1='12.23'
s2='12'
s3=True
s4='hellow'
s5=55
print(type(s1),type(s2),type(s3),type(s4),type(s5))
print(float(s2),type(float(s2)))
print(float(s3),type(float(s3)))
#print(float(s4),type(float(s4))) 非数字串不允许转换
print(float(s5),type(float(s5)))
运行结果：
我叫张三今年12岁
----------------------str()将其他数据类型转换成咸str------------------------
<class ‘int’> <class ‘float’> <class ‘bool’>
10 1.254 False <class ‘str’> <class ‘str’> <class ‘str’>
--------int()将其他类型转换成int-------------
<class ‘str’> <class ‘float’> <class ‘str’> <class ‘bool’> <class ‘str’>
111 <class ‘int’>
22 <class ‘int’>
1 <class ‘int’>
--------float()函数，把其类型转换成float类型----------
<class ‘str’> <class ‘str’> <class ‘bool’> <class ‘str’> <class ‘int’>
12.0 <class ‘float’>
1.0 <class ‘float’>
55.0 <class ‘float’>
input（）函数
#input默认str
question=input('你是谁')
print(question,type(question))
你是谁孙悟空
孙悟空 <class ‘str’>
#input是str类型需要转换
a1=int(input('请输入第一个数：'))
a2=int(input('请输入第二个数：'))
print(a1+a2)
请输入第一个数：22
请输入第二个数：33
55
运算符
#算数运算符
print(1+1) #执行加法运算
print(2-3)
print(2*3)
print(7/2)
print(11//2) #整除运算
print(33%2)
print(2**16) #幂运算
print(-3//2) #一正一负向下取整
print((3//-2))
print(-9%4) #余数=被除数-除数*商
print(9%-4)
运行结果：
2
-1
6
3.5
5
1
65536
-2
-2
3
-3
#赋值运算符 运算顺序从右到左
q=3+4
print(q)
a=b=c=99
print(a,id(a))
print(b,id(b))
print(c,id(c))
print('-----------参数赋值------------')
aa=2
aa+=33 #a=a+33
print(aa)
print('----------系列解刨赋值')
a,b,c=2,3,4
print(a,b,c)
print('-------交换两个变量的值-------')
a,b=44,55
print('交换之前',a,b)
a,b=b,a
print('交换之后',a,b)
运行结果：
7
99 2563703639344
99 2563703639344
99 2563703639344
-----------参数赋值------------
35
----------系列解刨赋值
2 3 4
-------交换两个变量的值-------
交换之前 44 55
交换之后 55 44
#比较运算符
a,b=22,33
print('a>b?',a>b) #False
print('a<b?',a<b) #True
print('a>=b?',a>=b) #False
print('a<=b?',a<=b) #True
# 一个=是赋值运算 两个==是比较运算 一个变量 标识，类型，值 ==比较的是值 比较对象用is
a=10
b=10
print(a==b) #False 说明a与b的值相等
print(a is b) #False 说明a与b的id标识相等
print('----list------')
list1=[1,2,3]
list2=[1,2,3]
print(list1==list2)
print(list1 is list2)
print(id(list1),id(list2))
print(a is not b) # Flase a与b的id不相等 他俩相等
print(list1 is not list2) #True id标识不相等
运行结果：
a>b? False
a<b? True
a>=b? False
a<=b? True
True
True
----list------
True
False
1190553646144 1190557288960
False
True
#布尔运算符
a,b=1,2
print(a==1and b==2) #True and True True
print(a==1 and b<2) #True and False False
#and 并且 or或者 not对运算数（布尔类型操作数）取反
print('------in 与 not in------')
a='asadsa'
print('a' in a) #a在a里
print('d' not in a) #a不在a里
运行结果：
True
False
------in 与 not in------
True
False
#位运算符
#位与& 对应数都是1才为1
#位或| 对应都是0才为0
#左移运算符<< 高位溢出丢弃，低位补零
#右移运算符 >> 低位溢出舍弃 ，高位补零
布尔值
#测试对象的布尔值
print(bool(False)) #False
print(bool(0)) #False
print(bool(0.0)) #False
print(bool(None)) #False
print(bool('')) #False
print(bool("")) #False
print(bool([])) #False 空列表
print(bool(list())) #False 空列表
print(bool(())) #False 空元组
print(bool(tuple())) #False 空元组
print(bool({})) #False 空字典
print(bool(dict())) #False 空字典
print(bool(set())) #False 空集合
print('------以上对象的布尔值为 False 其他对象的布尔值均为True')
print(bool('dad')) #True
单分支结构
#选择分支
money=1000 #余额
a=int(input('请输入取款金额：')) #取款金额
#判断余额是否充足
if money>=a:
money=money-a
print('取款成功，余额为：',money)
运行结果：
请输入取款金额：11
取款成功，余额为： 989
双分支
#双分支
num=int(input('请输入一个整数'))
#条件判断
if num%2==0:
print(num,'是偶数')
else:
print(num,'是奇数')
运行结果：
请输入一个整数2
2 是偶数
多分支
#多分支
score=int(input('请输入一个成绩：'))
if 90<=score<=100:
print('A')
elif score>=80 and score<=90:
print('B')
elif score>=70 and score<=80:
print('C')
elif score>=60 and score<=70:
print('D')
else:
print('大笨蛋！！！')
运行结果：
请输入一个成绩：0
大笨蛋！！！
嵌套if
#嵌套if
answer=input('你是会员吗？y/n')
money=int(input('请输入购物金额：'))
#外层判断是否为会员
if answer=='y':
if money>=200:
print('付款金额为：',money*0.7)
elif money>=100:
print('付款金额为：',money*0.8)
elif money>=50:
print('付款金额为：',money*0.99)
else:
print('抱歉，你无法享受此优惠')
print('会员')
else:
if money>=300:
print('打九折，应付：',money*0.9)
else:
print('不打折',money)
运行结果为：
你是会员吗？y/nn
请输入购物金额：5
不打折 5
条件表达式
#条件表达式
num1=int(input('请输入第一个数：'))
num2=int(input('请输入第二个整数：'))
#比较大小
if num1>=num2:
print(num1,'>=',num2)
else:
print(num1,'<',num2)
print('------使用条件表达式进行比较------')
#条件判断为True执行左侧否则执行右侧
print(str(num1)+'>='+str(num2) if num1>=num2 else str(num1)+'<'+str(num2))
执行结果为：
请输入第一个数：2
请输入第二个整数：2
2 >= 2
------使用条件表达式进行比较------
2>=2
pass语句
#pass语句
#什么都不做，只是一个占位符，用到需要的地方，使语句不报错
answer=input('你是会员吗?y/n')
#判断是否为会员
if answer=='y':
pass
else:
pass
rang()函数
#range函数的使用
#注：所有的rang函数都是一样大的，空间只有使用的时候才被占用
#三种创建方式
a=range(10) #默认从零开始，相差1
print(a)
print(list(a)) #list是列表
a=range(1,10) #指定开始和结束，，不包括结束的值
print(list(a))
a=range(1,100,5)
print(list(a))
#判断指定的整数是否存在 in , not in
print(1 in a)
print(1000 not in a)
运行结果：
range(0, 10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 6, 11, 16, 21, 26, 31, 36, 41, 46, 51, 56, 61, 66, 71, 76, 81, 86, 91, 96]
True
True
while循环
次数不确定
#while循环
#计算0-4之间的累加和
a=0
b=0
while a<5:
b+=a
a+=1
print(b)
运行结果为：
10
练习：
#计算1-100之间的偶数和
sun=0
a=0
while a<=100:
if a%2==0: #a%2=0可换成 not bool(a%2) bool()是False not取反
sun+=a
a+=1
print(sun)
运行结果：
2550
for in 循环
遍历可迭代对象
#for in 循环 for 自定义对象 in 可迭代对象（目前、字符串、序列）
for item in 'python':#循环输出python字符
print(item)
print('=================')
#range()产生一个整数序列 也是一个可迭代对象
for i in range(5):
print(i)
#如果在循环体中不需要使用到自定义变量，可将自定义变量写为“_"
for _ in range(2):
print('人生苦短')
#计算1-100的累加和
sum=0
for i in range(101):
sum+=i
print(sum)
#输出100-999之间的水仙花数
for num in range(100,1000):
ge=num%10
shi=num//10%10
bai=num//100
if ge**3+shi**3+bai**3==num:
print(num)
运行结果：
p
y
t
h
o
n
=================
0
1
2
3
4
人生苦短
人生苦短
5050
153
370
371
407
流程控制语句break
#从键盘输入密码、最多输入三次、如果正确就结束循环
for num in range(3):
pwd=input('请输入密码：')
if pwd=='888':
print('密码正确')
break
else:
print('密码不正确')
a=0
while a<3:
psw=input('请输入密码：')
if psw=='8888':
print('密码正确')
break
else:
print('密码错误')
a+=1
运行结果
请输入密码：888
密码正确
请输入密码：55
密码错误
请输入密码：55
密码错误
请输入密码：55
密码错误
流程控制语句continue
#流程控制语句continue
#是跳出当前循环进入下一个循环
#输出1-50之间五的倍数
for item in range(1,51):
if item%5==0:
print(item)
print('----------------使用continue-------------------')
for ite in range(1,51):
if ite%5!=0:
continue
print(ite)
执行结果：
5
10
15
20
25
30
35
40
45
50
----------------使用continue-------------------
5
10
15
20
25
30
35
40
45
50
else语句
#else语句
for item in range(3):
pwd=input('请输入密码:')
if item=='8888':
print('密码正确！！！')
break
else:
print('密码错误！！！')
else:
print('对不起，今日次数已用完！！！')
执行结果：
请输入密码:5
密码错误！！！
请输入密码:4
密码错误！！！
请输入密码:4
密码错误！！！
对不起，今日次数已用完！！！
#while语句实现
a=0
while a<3:
pwd=input('请输入密码：')
if pwd=='8888':
print('密码正确！！！')
break
else:
print('密码错误！！！')
a+=1
else:
print('对不起，请明天再来！！！')
执行结果：
请输入密码：4
密码错误！！！
请输入密码：ds
密码错误！！！
请输入密码：ds
密码错误！！！
对不起，请明天再来！！！
嵌套循环
#嵌套循环
#输出一个三行四列矩形
for i in range(1,4):
for j in range(1,5):
print('*',end='\t')#不换行输出
print()
print('------------------------------------')
for i in range(1,10):
for j in range(i):
print('*',end='\t')
print()
print('输出九九乘法表：')
for i in range(1,10):
for j in range(1,i+1):
print(j,'*',i,'=',i*j,end='\t')
print()
执行结果：
输出九九乘法表：
1 * 1 = 1
1 * 2 = 2 2 * 2 = 4
1 * 3 = 3 2 * 3 = 6 3 * 3 = 9
1 * 4 = 4 2 * 4 = 8 3 * 4 = 12 4 * 4 = 16
1 * 5 = 5 2 * 5 = 10 3 * 5 = 15 4 * 5 = 20 5 * 5 = 25
1 * 6 = 6 2 * 6 = 12 3 * 6 = 18 4 * 6 = 24 5 * 6 = 30 6 * 6 = 36
1 * 7 = 7 2 * 7 = 14 3 * 7 = 21 4 * 7 = 28 5 * 7 = 35 6 * 7 = 42 7 * 7 = 49
1 * 8 = 8 2 * 8 = 16 3 * 8 = 24 4 * 8 = 32 5 * 8 = 40 6 * 8 = 48 7 * 8 = 56 8 * 8 = 64
1 * 9 = 9 2 * 9 = 18 3 * 9 = 27 4 * 9 = 36 5 * 9 = 45 6 * 9 = 54 7 * 9 = 63 8 * 9 = 72 9 * 9 = 81
二重循环中的break和continue
跳出本层循环
列表
#列表的创建
#使用中括号
list1=['hellow','word',66]
#使用内置函数；list（）
list2=list(['hellow','word',77])
#获取索引为2的元素
print(list1[2])
#获取索引为-2的元素
print(list1[-2])
#获取列表的多个元素 start：1 stop：3 step:1
print(list2[1:3:1])
#step为负的情况
print(list1[::-1])
运行结果：
66
word
[‘word’, 77]
[66, ‘word’, ‘hellow’]
列表元素的添加操作
#在列表中添加元素
list=[10,20,30,40,50]
list.append(60)#在末尾添加一个元素
print(list)
list1=[70,80]
list.extend(list1)#在末尾添加多个元素
print(list)
list.insert(2,401)#在任意位置添加一个元素
print(list)
list2=['das','as']
list[1:]=list2#在任意位置添加任意个元素，相当于把要插入位置后面的元素切掉，添加新的元素
print(list)
执行结果：
[10, 20, 30, 40, 50, 60]
[10, 20, 30, 40, 50, 60, 70, 80]
[10, 20, 401, 30, 40, 50, 60, 70, 80]
[10, ‘das’, ‘as’]
列表元素的删除操作
#列表元素的删除操作
#remove() 移除列表中的一个元素，若列表中有重复的数则移除第一个
list=[10,20,30,40,50,60,30]
list.remove(30)
print(list)
#pop()移除指定索引元素，若不指定位置则删除最后一个元素
list.pop(4)
print(list)
list.pop()
print(list)
print('------切片，删除至少一个元素，将产生一个新的列表对象------')
print('原列表：',list)
new_list=list[1:3]
print('切片后的列表：',new_list)
'''不产生新的列表对象，而是删除原列表中的内容'''
list[1:3]=[]
print(list)
'''清除列表中的所有元素'''
list.clear()
print(list)
'''删除列表对象'''
del list
print(list)
执行结果：
[10, 20, 40, 50, 60, 30]
[10, 20, 40, 50, 30]
[10, 20, 40, 50]
------切片，删除至少一个元素，将产生一个新的列表对象------
原列表： [10, 20, 40, 50]
切片后的列表： [20, 40]
[10, 50]
[]
<class ‘list’>
列表元素的修改
#列表元素的修改
list=[10,20,30,40]
#一次修改一个值
list[2]=100
print(list)
#使用切片对列表中的多个元素进行修改
list[1:3]=[200,300,500]
print(list)
执行结果:
[10, 20, 100, 40]
[10, 200, 300, 500, 40]
列表元素的排序
#列表元素的排序
list=[20,40,10,98,58]
print('排序前的列表',list,id(list))
#sort()升序
list.sort()
print('排序后的列表',list,id(list))
#通过指定关键字参数，将列表元素进行降序
list.sort(reverse=True)#Flase时是升序
print('降序后的列表',list,id(list))
#使用内置函数sorted()对列表进行排序，将产生一个新的列表对象
list1=[10,50,60,20,70,30,90,1]
print('原列表：',list1,id(list1))
new_list1=sorted(list1)
print('排序后：',list1,id(new_list1))
#指定关键字实现降序
desc_list1=sorted(list1,reverse=True)
print('降序后：',desc_list1)
执行结果：
排序前的列表 [20, 40, 10, 98, 58] 2111360136512
排序后的列表 [10, 20, 40, 58, 98] 2111360136512
降序后的列表 [98, 58, 40, 20, 10] 2111360136512
原列表： [10, 50, 60, 20, 70, 30, 90, 1] 2111360089664
排序后： [10, 50, 60, 20, 70, 30, 90, 1] 2111360087296
降序后： [90, 70, 60, 50, 30, 20, 10, 1]
列表表达式
#列表生成式
list=[i*i for i in range(1,10)]
print(list)
'''列表元素中的值为2，4，6，8，10'''
list1=[a*2 for a in range(1,6)]
print(list1)
执行结果：
[1, 4, 9, 16, 25, 36, 49, 64, 81]
[2, 4, 6, 8, 10]
字典的创建
#字典的创建
#使用花括号
scores={'张三':100,'李四':200,'王二':300}
print(scores,type(scores))
#使用内置函数dict()
student=dict(name='jack',age=20)
print(student)
#创建空字典
d={}
print(d)
执行结果：
{‘张三’: 100, ‘李四’: 200, ‘王二’: 300} <class ‘dict’>
{‘name’: ‘jack’, ‘age’: 20}
{}
字典元素的获取
#字典元素的获取
scores={'张三':100,'李四':200,'王二':300}
'''使用[] 在查找一个不存在的元素时会报错，keyError'''
print(scores['张三'])
'''使用get()方法 在查找一个不存在的元素时并不会报错而会输出None'''
print(scores.get('张三'))
print(scores.get('傻瓜'))
print(scores.get('大',99))#99是在查找’大‘所对应的value值不存在时，所提供的一个默认值
执行结果：
100
100
None
99
字典的常用操作
#字典的常用操作
'''键的判断'''
scores={'张三':100,'李四':200,'王二':300}
print('张三' not in scores)
print('是' in scores)
'''字典的指定删除'''
del scores['张三']
print(scores)
'''清空字典元素'''
scores.clear()
print(scores)
'''字典的新增'''
scores['猪八戒']=55
print(scores)
'''修改元素'''
scores['猪八戒']=555
print(scores)
执行结果：
False
False
{‘李四’: 200, ‘王二’: 300}
{}
{‘猪八戒’: 55}
{‘猪八戒’: 555}
字典的视图
#字典的视图
scores={'张三':100,'李四':200,'王二':300}
key=scores.keys()
print(key)#获取所有的key
print(list(key))#将获取的key转换成列表
value=scores.values()#获取所有的value
print(value)
items=scores.items()#获取所有的key与value
print(items)
print(list(items))#这里的元素是元组
执行结果:
dict_keys([‘张三’, ‘李四’, ‘王二’])
[‘张三’, ‘李四’, ‘王二’]
dict_values([100, 200, 300])
dict_items([(‘张三’, 100), (‘李四’, 200), (‘王二’, 300)])
[(‘张三’, 100), (‘李四’, 200), (‘王二’, 300)]
字典元素的遍历
#字典元素的遍历
scores={'张三':100,'李四':200,'王二':300}
for item in scores:
print(item,scores[item],scores.get(item))
执行结果：
张三 100 100
李四 200 200
王二 300 300
字典的特点
字典生成式
#字典生成式
items=['Fruits','Books','Others']
prices=[96,78,85]
d={item.upper():price for item ,price in zip(items,prices)}#若两列表元素数不一致，以少的为准
print(d)
执行结果：
{‘FRUITS’: 96, ‘BOOKS’: 78, ‘OTHERS’: 85}
可变序列与不可变序列
可变序列：列表、字典、集合（没有value值的字典）
可以对序列执行增删改操作，对象地址不发生改变不可变序列：字符串、元组
没有增删改查的操作，执行后会改变对象地址
元组
#元组
#python的内置数据结构之一，是不可变序列
'''使用小括号创建元组,小括号可以省略'''
t=('hellow','word',98)
print(type(t))
print(t)
'''记住元组只有一个元素时要加上逗号，否则会默认为string类型'''
t2=('python')
print(type(t2))
print(t2)
t3=('java',)
print(type(t3))
'''使用内置函数tuple创建元组'''
t1=tuple(('heloow','java',100))
print(type(t1))
print(t1)
'''空元组的创建方式'''
t4=()
t5=tuple()
print('空元组:',t4,t5)
执行结果
<class ‘tuple’>
(‘hellow’, ‘word’, 98)
<class ‘str’>
python
<class ‘tuple’>
<class ‘tuple’>
(‘heloow’, ‘java’, 100)
空元组: () ()
元组的遍历
#元组的遍历
t=('hellow','python',55)
'''通过索引'''
print(t[0])
print(t[1])
print('------通过遍历------')
for item in t:
print(item)
执行结果
hellow
python
------通过遍历------
hellow
python
55
集合
#集合不能重复
'''使用花括号创建集合'''
s={2,3,4,5,5,6,7,7}
print(s)
'''使用内置函数set()'''
s1=set(range(6))
print(s1,type(s1))
'''创建空集合'''
s2={}#不能直接用花括号创建空集合，这样创建的是字典类型
print(s2,type(s2))
s3=set()
print(s3,type(s3))
执行结果
{2, 3, 4, 5, 6, 7}
{0, 1, 2, 3, 4, 5} <class ‘set’>
{} <class ‘dict’>
set() <class ‘set’>
集合的判断
#集合的相关操作
#集合的判断操作
s={10,20,30}
print(10 in s)#True
print(5555 in s)#False
print(2 not in s)#True
集合的添加
#集合的新增
s={10,20,30}
s.add(60)
print(s)
s.update({200,300,400})
print(s)
执行结果
{10, 20, 30, 60}
{400, 20, 300, 200, 10, 60, 30}
集合的删除
#集合的删除
s={100,200,300}
print(s)
s.remove(100)#一次删除一个指定元素、若指定元素不存在则抛出异常
print(s)
s.discard(30000)#一次删除一个指定元素，若元素不存在，不会抛出异常
print(s)
s.pop()#一次删除一个，随机 只能无参
print(s)
s.clear()#清除集合
print(s)
执行结果
{200, 100, 300}
{200, 300}
{200, 300}
{300}
set()
集合之间的关系
#判断两个集合是否相等
s1={10,20,30,40}
s2={40,30,20,10}
print(s1!=s2)#Fase
print(s1==s2)#True
#一个集合是否是另一个集合的子集
s1={10,20,30,40}
s2={40,30}
s3={40,50}
print(s2.issubset(s1))#True
print(s3.issubset(s1))#False
#一个集合是否是另一个集合的超集
print(s1.issuperset(s2))#True
print(s1.issuperset(s3))#False
#两个集合是否有交集 isdisjoint:是不含有交集的
print(s2.isdisjoint(s3))#False
s4={55,66,44}
print(s3.isdisjoint(s4))#True
集合的数学操作
#集合的数学操作
print('------交集------')
s1={10,20,30,40}
s2={30,40,50,60}
print(s1.intersection(s2))
print(s1 & s2)
print('------并集------')
print(s1.union(s2))
print(s1 | s2)
print('------差集------')
print(s1.difference(s2))
print(s1-s2)
print('------对称差集------')
print(s1.symmetric_difference(s2))
print(s1 ^ s2)
执行结果
------交集------
{40, 30}
{40, 30}
------并集------
{40, 10, 50, 20, 60, 30}
{40, 10, 50, 20, 60, 30}
------差集------
{10, 20}
{10, 20}
------对称差集------
{10, 50, 20, 60}
{10, 50, 20, 60}
集合生成式
#集合生成式
s={i*i for i in range(10)}
print(s)
#{0, 1, 64, 4, 36, 9, 16, 49, 81, 25}
总结
字符串
#字符串
#字符串的驻留机制，相同的元素在驻留池只保留一份，后续创建相同的字符串时，不会开辟新空间，把该字符的地址赋给新创建的变量
s='python'
s1="python"
s2='''python'''
print(s,id(s),s1,id(s1),s2,id(s2))
#python 2660316022192 python 2660316022192 python 2660316022192
'''驻留机制的几种情况
字符串长度为0或1时
符合标识符的字符串
字符串只在编译时驻留、而非运行时
-5到256之间的整数数字
sys中的intern方法强制2个字符串指向同一个对象
pycharm 对字符串进行了优化处理
'''
字符串的查找
#字符串的查找 查找的值不存在时会抛异常
s='hellow,hellow'
print(s.index('lo'))#3
print(s.find('lo'))#3
print(s.rindex('lo'))#10
print(s.rfind('lo'))#10
字符串的常用操作
#字符串的大小写转化
s='helloe,python'
print(s,id(s))
a=s.upper()#把所有字符串转变成大写之后会产生一个新的字符串对象
print('把所有字符串转变成大写',a,id(a))
b=s.lower()#产生一个新的字符串对象
print('把所有字符串转换成小写',b,id(b))
print('把所有大写转变成小写、小写转成大写',s.swapcase())
print('把每个单词的首字母大写，其余为小写',s.title())
print('把第一个字符转成大写，其余小写',s.capitalize())
执行结果
helloe,python 2000741860784
把所有字符串转变成大写 HELLOE,PYTHON 2000741860400
把所有字符串转换成小写 helloe,python 2000741875504
把所有大写转变成小写、小写转成大写 HELLOE,PYTHON
把每个单词的首字母大写，其余为小写 Helloe,Python
把第一个字符转成大写，其余小写 Helloe,python
字符串对齐操作
#字符串的对齐操作
s='hellow,python'
print(s.center(20,'*'))#剧中 第一个参数是指定宽度，第二个参数是填充字符
print(s.ljust(20,'*'))#左对齐 第一个参数是指定宽度，第二个参数是填充字符 默认是空格
print(s.ljust(10))
print(s.rjust(20,'*'))
print(s.rjust(20))
print(s.zfill(20))#右对齐，用0进行填充
print('-8910'.zfill(8))
执行结果
hellow,python*
hellow,python*******
hellow,python
*******hellow,python
hellow,python
0000000hellow,python
-0008910
字符串分劈操作
#字符串的分割
s='hello word python'
list=s.split()
print(list)
s1='hello|word|python'
print('从左边开始劈分')
print(s1.split())
print(s1.split(sep='|'))#指定分劈符
print(s1.split(sep='|',maxsplit=1))#指定最大劈分次数
print('从右边开始劈分')
print(s.rsplit())
print(s1.rsplit(sep='|'))
print(s1.rsplit(sep='|',maxsplit=1))
执行结果为
[‘hello’, ‘word’, ‘python’]
从左边开始劈分
[‘hello|word|python’]
[‘hello’, ‘word’, ‘python’]
[‘hello’, ‘word|python’]
从右边开始劈分
[‘hello’, ‘word’, ‘python’]
[‘hello’, ‘word’, ‘python’]
[‘hello|word’, ‘python’]
判断字符串的组成
isidentifier() 判断指定字符串是不是合法的标识符
isspace() 判断指定的字符串是否全部由空白字符串组成（回车、换行、水平制表符）
isalpha() 判断指定字符串是否全部由字母组成
isdecimal() 判断指定字符串是否全由十进制数组成
isnumeric() 判断指定的字符串是否全部由数字组成
isalnum() 判断指定字符串是否全部由字母数字组成
字符串的替换和合并
#字符串的替换与合并
s='hello,python'
print(s.replace('python','java'))
s1='hello,python,python,python'
print(s1.replace('python','java',2))#2第三个参数2代表可替换的最大次数
print('------字符串的合并------')
list=['hello','java','python']
print('|'.join(list))
print(''.join(list))
t=('hello','java')
print(''.join(t))
print('*'.join('python'))
执行结果
hello,java
hello,java,java,python
------字符串的合并------
hello|java|python
hellojavapython
hellojava
pytho*n
字符串的切片操作
#字符串的切片操作 会形成新的对象
s='hello,python'
s1=s[:5]
print(s1)
s2=s[6:]
print(s2)
s3='!'
newstr=s1+s3+s2
print(newstr)
print(s[1:5:1])#从一开始到五结束，不包括五，步长为1
执行结果
hello
python
hello!python
ello
字符串格式化
#字符串格式化
name='张三'
age=23
print('我叫%s,今年%d岁了！'%(name,age))
print('我叫{0}，今年{1}岁了！'.format(name,age))
print(f'我叫{name},今年{age}岁了')
print('%10d' % 99)#10为宽度
print('%.3f' % 3.14532)#.3表示保留小数点后三位
print('%10.3f' % 3.14532)#同时保留精度和宽度
print('------使用花括号------')
print('{0:.3}'.format(3.1452654885))#.3表示一共三位数
print('{:.3f}'.format(3.14562566525))#.3f表示三位小数
print('{:10.3f}'.format(3.14562566525))#同时设置宽度和精度 一共十位，三位小数
执行结果
我叫张三,今年23岁了！
我叫张三，今年23岁了！
我叫张三,今年23岁了
99
3.145
3.145
------使用花括号------
3.15
3.146
3.146
字符串的编码与解码
#字符串的编码与解码
s='天涯共此时'
#编码
print(s.encode(encoding='GBK'))#在GBK中，一个中文占两个字节
print(s.encode(encoding='UTF-8'))#一个中文占三个字节
#解码
#byte代表一个二进制数据（字节类型的数据）
byte=s.encode(encoding='GBK')#编码
print(byte.decode(encoding='GBK'))#解码
byte=s.encode(encoding='UTF-8')
print(byte.decode(encoding='UTF-8'))
执行结果
b’\xcc\xec\xd1\xc4\xb9\xb2\xb4\xcb\xca\xb1’
b’\xe5\xa4\xa9\xe6\xb6\xaf\xe5\x85\xb1\xe6\xad\xa4\xe6\x97\xb6’
天涯共此时
天涯共此时
函数的创建与调用
#函数的创建
def calc(a,b):#a,b为形式参数（形参）出现在函数的定义处
c=a+b
return c
#位置实参
result=calc(10,20)#10，20为实参的值，出现在函数的调用处
print(result)#30
#关键字实参
res=calc(b=20,a=10)
print(res)#30
函数参数的传递
#函数参数的传递
def fun(arg1,arg2):
print('arg1=',arg1)
print('arg2=',arg2)
arg1=100
arg2.append(10)
print('arg1=', arg1)
print('arg2=', arg2)
n1=11
n2=[22,33,44]
print('n1=',n1)
print('n2=',n2)
fun(n1,n2) #实参与形参的名称可以不一样
print('n1=',n1)
print('n2=',n2)
'''在函数调用过程中，进行参数的传递
如果是不可变对象，在函数体的修改不会影响实参的值 arg1的修改为100，不会影响n1的值
如果是可变对象，在函数体的修改会影响到实参的值 arg2的修改，append(10)，会影响n2的值
'''
执行结果
n1= 11
n2= [22, 33, 44]
arg1= 11
arg2= [22, 33, 44]
arg1= 100
arg2= [22, 33, 44, 10]
n1= 11
n2= [22, 33, 44, 10]
函数的返回值
#函数的返回值
def fun(num):
odd=[]#存奇数
even=[]#存偶数
for i in num:
if i%2:
odd.append(i)
else:
even.append(i)
return odd,even
#函数的调用
lst=[10,29,34,23,44,53,55]
print(fun(lst))
'''函数的返回值
1、如果函数没有返回值【函数执行完毕后、不需要给调用处提供数据】return可省略不屑
2、函数的返回值、如果是一个、直接返回类型
3、函数的返回值、如果是多个、返回的结果为元组
'''
def fun1():
print('hello')
#return
fun1()
def fun2():
return 'hello'
res=fun2()
print(res)
def fun3():
return 'hello','word'
print(fun3())
'''函数用不用返回值，视情况而定'''
执行结果
([29, 23, 53, 55], [10, 34, 44])
hello
hello
(‘hello’, ‘word’)
函数参数的定义默认值参数
#函数的参数定义
def fun(a,b=23):#b=23为默认参数
print(a,b)
fun(100)#一个参数时会赋值给a
fun(10,30)#两个参数，10赋值给a30赋值给b
执行结果
100 23
10 30
函数参数的定义–个数可变的位置形参–个数可变的关键字形参
def fun(*arg):#函数定义时的 可变的位置参数 结果是一个元组
print(arg)
fun(10)
fun(11,22,33)
fun(44,55,66,88,99)
def fun1(**args):#函数定义时的 可变的关键字参数 结果是一个字典
print(args)
fun1(a=10)
fun1(a=11,b=22,c=99)
'''
定义函数时，个数可变的位置形参，个数可变的关键字形参只能有一个
定义函数时，要是同时有个数可变的位置形参也有个数可变的关键字形参，要求个数可变的位置形参在前面
'''
执行结果
(10,)
(11, 22, 33)
(44, 55, 66, 88, 99)
{‘a’: 10}
{‘a’: 11, ‘b’: 22, ‘c’: 99}
参数的转换
#实参的转换
def fun(a,b,c):#a,b,c在函数的定义处，是形参
print('a=',a)
print('b=',b)
print('c=',c)
#函数的调用
fun(10,20,30)#函数调用时的参数传递、称为位置传参
list=[11,22,33]
fun(*list)#在函数调用时、将列表中的每个元素都转换为位置实参传入 *
print('--------------------')
fun(a=88,b=99,c=44)#函数的调用、关键字实参
dict={'a':100,'b':200,'c':300}
fun(**dict)#在函数调用时、将字典中的键值对都转换为关键字实参传入 **
print('-------------------')
def fun1(a,b,*,c,d):# 调用时*后面的只能关键字传参
print('a=',a)
print('b=', b)
print('c=', c)
print('d=', d)
fun1(10,20,c=77,d=0)
执行结果
a= 10
b= 20
c= 30
a= 11
b= 22
c= 33----------------------------
a= 88
b= 99
c= 44
a= 100
b= 200
c= 300---------------------------
a= 10
b= 20
c= 77
d= 0
变量的作用域
变量的作用域
局部变量，在函数内定义并使用的变量，只在函数内部有效，局部变量使用global声明就会变成全局变量
全局变量、函数体外定义的变量、可作用于函数内外
递归函数
def fun(n):
if n==1:
return 1
else:
return n*fun(n-1)
print(fun(6))#720
斐波那契数列
#斐波那契数列
def fib(n):
if n==1:
return 1
elif n==2:
return 1
else:
return fib(n-1)+fib(n-2)
#输出第六位的数
print(fib(6))
print('------------------')
#输出前六位的数
for i in range(1,7):
print(fib(i))
执行结果
8------------------
1
1
2
3
5
8
try-except-else
try:
a=int(input("请输入第一个整数"))
b=int(input("请输入第一个整数"))
result = a/b
except BaseException as e:
print("出错了")
else:
print("计算结果为：",result)
执行结果为
请输入第一个整数10
请输入第一个整数20
计算结果为： 0.5
try-except-else-finally
#finally块无论是否发生异常都会执行，常用来释放try块中申请的资源
try:
a=int(input("请输入第一个整数"))
b=int(input("请输入第一个整数"))
result = a/b
except BaseException as e:
print("出错了",e)
else:
print("计算结果为：",result)
finally:
print("谢谢使用")
print("程序结束")
执行结果
请输入第一个整数20
请输入第一个整数50
计算结果为： 0.4
谢谢使用
程序结束
常见异常
trackback模块
#traceback模块 打印异常信息
import traceback
try:
print("--------------")
print(1/0)
except:
traceback.print_exc()
执行结果
Traceback (most recent call last): --------------
File “D:\dudu\pycharmfile\demo8.py”, line 65, in
print(1/0)
ZeroDivisionError: division by zero
定义python中的类
#定义python中的类
class Student:
native_pace='河南'#直接在类里的属性，称为类属性
#初始化方法
def __init__(self,name,age):
self.name=name #self.name称为实体属性，进行了一个赋值操作，将局部变量的name赋值给实体属性
self.age=age
#实例方法
def eat(self):
print("学生在吃饭。。。")
#静态方法
@staticmethod
def method():
print('我使用了staticmethod进行修饰，所以我是静态方法')
#类方法
@classmethod
def cm(cls):
print('我是类方法，因为我用classmethod修饰')
#在类之外称为函数，在类之内称为方法
def drink():
print("喝水")
对象的创建
#定义python中的类
class Student:
native_pace='河南'#直接在类里的属性，称为类属性
#初始化方法
def __init__(self,name,age):
self.name=name #self.name称为实体属性，进行了一个赋值操作，将局部变量的name赋值给实体属性
self.age=age
#实例方法
def eat(self):
print("学生在吃饭。。。")
#静态方法
@staticmethod
def method():
print('我使用了staticmethod进行修饰，所以我是静态方法')
#类方法
@classmethod
def cm(cls):
print('我是类方法，因为我用classmethod修饰')
#在类之外称为函数，在类之内称为方法
def drink():
print("喝水")
#对象的创建
#创建Student类的对象
stu1=Student('张三',20)
stu1.eat()
print(stu1.name)
print(stu1.age)
print('------------------')
Student.eat(stu1)#此行和stu1.eat()代码相同，都是调用Student中的eat方法
#类名，方法名（类的对象）---》实际上就是方法定义处的self
执行结果
学生在吃饭。。。
张三
20------------------
学生在吃饭。。。
类属性-类方法-静态方法
#定义python中的类
class Student:
native_pace='河南'#直接在类里的属性，称为类属性
#初始化方法
def __init__(self,name,age):
self.name=name #self.name称为实体属性，进行了一个赋值操作，将局部变量的name赋值给实体属性
self.age=age
#实例方法
def eat(self):
print("学生在吃饭。。。")
#静态方法
@staticmethod
def method():
print('我使用了staticmethod进行修饰，所以我是静态方法')
#类方法
@classmethod
def cm(cls):
print('我是类方法，因为我用classmethod修饰')
#在类之外称为函数，在类之内称为方法
def drink():
print("喝水")
#类属性的使用方法
print(Student.native_pace)
stu1=Student('张三',20)
stu2=Student('李四',30)
print(stu1.native_pace)
print(stu2.native_pace)
Student.native_pace='周口'
print(stu1.native_pace)
print(stu2.native_pace)
print('*********类方法的使用方式***********')
Student.cm()
print('*********静态方法的使用方式***********')
Student.method()
执行结果
河南
河南
河南
周口
周口
类方法的使用方式**
我是类方法，因为我用classmethod修饰
静态方法的使用方式**
我使用了staticmethod进行修饰，所以我是静态方法
动态绑定属性和方法
class Student:
def __init__(self,name,age):
self.name=name
self.age=age
def eat(self):
print(self.name+'在吃饭')
stu1=Student('张三',20)
stu2=Student('李四',60)
print('***为stu2动态绑定性别属性*')
stu2.gender='男'
print(stu1.name,stu1.age)
print(stu2.name,stu2.age,stu2.gender)
stu1.eat()
stu2.eat()
def show():
print('定义在类之外的称为函数')
stu1.show=show
stu1.show()
执行结果
**为stu2动态绑定性别属性
张三 20
李四 60 男
张三在吃饭
李四在吃饭
定义在类之外的称为函数
封装的实现
#封装的实现方式
class Car:
def __init__(self,brand):
self.brand=brand
def start(self):
print('汽车已启动。。。')
car=Car('宝马x5')
car.start()
print(car.brand)
#在python中没有专门的修饰符用于属性私有，如果该属性不希望在类对象外部被访问，前面使用两个__
class Student:
def __init__(self,name,age):
self.name=name
self.__age=age #在外部不能被使用
def show(self):
print(self.name,self.__age)
stu=Student('张三',20)
stu.show()
#在类外使用name和age
print(stu.name)
#print(stu.__age) 会报错，不能访问
#如果要访问的话使用 stu._Student__age
print(stu._Student__age)
执行结果
汽车已启动。。。
宝马x5
张三 20
张三
20
继承的实现
****python支持多继承****
#继承的实现方法 如果一个类没有继承任何类，默认继承Object类
#python支持多继承，在定义子类时。必须在其构造函数中调用父类的构造函数
class Person(object):
def __init__(self,name,age):
self.name=name
self.age=age
def info(self):
print(self.name,self.age)
class Student(Person):
def __init__(self,name,age,stu_no):
super().__init__(name,age)
self.stu_no=stu_no
class Teacher(Person):
def __init__(self,name,age,teachofyear):
super().__init__(name,age)
self.teachofyear=teachofyear
stu=Student('张三',20,'100')
teacher=Teacher('李四',50,'555')
stu.info()
teacher.info()
执行结果
张三 20
李四 50
方法的重写
class Person(object):
def __init__(self,name,age):
self.name=name
self.age=age
def info(self):
print(self.name,self.age)
class Student(Person):
def __init__(self,name,age,stu_no):
super().__init__(name,age)
self.stu_no=stu_no
def info(self):
super().info()
print(self.stu_no)
class Teacher(Person):
def __init__(self,name,age,teachofyear):
super().__init__(name,age)
self.teachofyear=teachofyear
def info(self):
super().info()
print('教龄：',self.teachofyear)
stu=Student('张三',20,'100')
teacher=Teacher('李四',50,'555')
stu.info()
teacher.info()
执行结果
张三 20
100
李四 50
教龄： 555
object类
class Student:
def __init__(self,name,age):
self.name=name
self.age=age
def __str__(self):#重写__str__（）方法用于返回对象的描述
return '我的名字是{0},今年{1}岁啦'.format(self.name,self.age)
stu=Student('张三',20)
#print(dir(stu))#dir()查看stu所具有的属性和方法
print(stu)
执行结果
我的名字是张三,今年20岁啦
多态的实现
#多态的实现
class Animal(object):
def eat(self):
print('动物吃东西。。。')
class Person(object):
def eat(self):
print('人吃五谷杂粮')
class Dog(Animal):
def eat(self):
print('狗吃骨头')
class Sheep(Animal):
def eat(self):
print('羊吃草')
def fun(animal):
animal.eat()
fun(Dog())
fun(Person())
fun(Sheep())
执行结果
狗吃骨头
人吃五谷杂粮
羊吃草
特殊属性
#特殊属性
class A:
pass
class B:
pass
class C(A,B):
def __init__(self,name,age):
self.name=name
self.age=age
#创建C类的对象
x=C('jack',20)#x是C类的实例对象
print(x.__dict__)#实例对象的属性字典
print(C.__dict__)
print(x.__class__)#输出对象所属的类
print(C.__bases__)#输出父类的元组
print(C.__base__)#输出C类的基类
print(C.__mro__)#查看C类的层次结构
print(A.__subclasses__())#查看A类的子类的列表
执行结果
{‘name’: ‘jack’, ‘age’: 20}
{‘module’: ‘main’, ‘init’: <function C.init at 0x000002124E57B0A0>, ‘doc’: None}
<class ‘main.C’>
(<class ‘main.A’>, <class ‘main.B’>)
<class ‘main.A’>
(<class ‘main.C’>, <class ‘main.A’>, <class ‘main.B’>, <class ‘object’>)
[<class ‘main.C’>]
特殊方法
#特殊方法
a=20
b=100
c=a+b
d=a.__add__(b)
print(c)
print(d)
class Student:
def __init__(self,name):
self.name=name
def __add__(self, other):
return self.name+other.name
def __len__(self):
return len(self.name)
stu1=Student('张三')
stu2=Student('李四')
s=stu1+stu2#实现了两个对象的加法（因为在Student类中编写了__add__（）方法）
s=stu1.__add__(stu2)
print(s)
print(len(stu1))
执行结果
120
120
张三李四
2
new init
#__new__ __init__
class Person(object):
def __new__(cls, *args, **kwargs):
print('__new__被调用执行了，cls的id值为{0}'.format(id(cls)))
obj=super().__new__(cls)
print('创建的对象的id为：{0}'.format(id(obj)))
def __init__(self, name, age):
print('__init__被调用了，self的id值为：{0}'.format(id(self)))
self.name = name
self.age = age
print('object这个类对象的id为：{0}'.format(id(object)))
print('Person这个类对象的id为：{0}'.format(id(Person)))
#创建Person类的实例对象
p=Person('张三',20)
print('p这个Person类的实例对象的id:{0}'.format(id(p)))
常用模块
编码格式
读取磁盘文件中的内容
file=open('a.txt','r',encoding='utf-8')
print(file.readlines())
file.close()
#['中国\n', '云台山']
a.txt
中国
云台山
常用的文件打开模式
src_file=open('520.gif','rb')
target_file=open('copy520.gif','wb')
target_file.write(src_file.read())
target_file.close()
src_file.close()
#把图片复制了一张
文件对象的常用方法
file=open('a.txt','r',encoding='utf-8')
#print(file.read(2))#读取两个字符
#print(file.readline())#读取一行
#print(file.readlines())#读取所有内容，并放到列表中
# file=open('b.txt','a',encoding='utf-8')
# #file.write('hello')
# list=['java','php']
# file.writelines(list)
# file.close()
file=open('b.txt','a',encoding='utf-8')
file.seek(2)
print(file.read())
print(file.tell())
file.close()
file=open('b.txt','a')
file.write('hello')
file.flush()
file.write('word')
file.close()
with语句
上下文管理器
自动管理上下文资源、不论什么原因跳出with块、都能确保文件正确的关闭，以此达到释放资源的目的
print(type(open('b.txt','r')))
with open('b.txt','r') as file:
print(file.read())
with open('11.gif','rb') as src_file:
with open('copy211.gif','wb') as target_file:
target_file.write(src_file.read())
os模块常用函数
#os模块与操作系统相关的一个模块
import os
# os.system('notepad.exe')#打开记事本
# os.system('calc.exe')#打开计算器
#直接调用可执行文件
os.startfile('D:\\software\\Tencent\\QQ\\Bin\\qq.exe')
import os
print(os.getcwd())
file=os.listdir('../pycharmfile')
print(file)
#os.mkdir('chap1')
#os.makedirs('a/d/c')
#os.rmdir('chap1')
#os.removedirs('a/d/c')
os.chdir('D:\\dudu\\pycharmfile\\chap1')
print(os.getcwd())
os.path模块
1551
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
