Python复习个人笔记期末
1. 基本数据类型
- 整数：int
- 浮点数：float
- 字符串：str
- 布尔:bool
- 复数：complex
2. 整型
- 二进制：0b或0B开头
- 八进制：0o或0O开头
- 十六进制：0x或0X开头
b = 0o71
c = 0x1A
# 二进制 八进制 十六进制
print(a,b,c)
输出为 5 57 26
3. 浮点型
print(.1)
print(5.678e2)
输出为 0.1 567.8
问题
0.1+0.2=0.30000000000000004
原因是计算机存储浮点数的方式。
print(0.2+0.1==0.3)
输出为False
4.复数
3.0+4.0j
type(3.0+4.0j)
# 复数类型complex
# 输出为 complex
a= type(0)
b= type(0j)
print(a,b)
# 复数必须写上虚部j，实部可以不写
print(1+1j)
# 不能写成1+j
输出结果为
<class 'int'> <class 'complex'>
(1+1j)
z = 3+4j
# 输出z的实部和虚部
print(z.real,z.imag)
3.0 4.0
5.一些函数使用
-
round
-
pow
-
len
-
abs
-
divmod
-
max、min
1、绝对值
abs(-10.9) # 输出结果为10.92、round
a = round(3.1415) # round 不加参数表示取整 b= round(3.6) # 有四舍五入 print(a,b) # 输出结果为 3 4另外
print(round(0.1+0.2,2)==0.3) # 输出结果为True3、len
可以求字符串的长度，等等
a = "abcdefg" len(a) # 输出为74、max
max(1,2,3,4,5,6) # max函数 # 输出为65、divmod
divmod(11,5) # 输出为(2,1)，分别是整除和取模的结果，其实输出的是一个元组6、pow
pow(3,2) # 输出为9 """ pow(x,y) 表示x的y次方 """
6.基础运算符
# + - * / // % **
2**3
# a**b表示a的b次方
print(3/2)
# 普通的除和整除符号//
print(3//2)
# 输出结果为 1.5 和 1
a =-11//5
# 向下取整
b = 11//5
print(a,b)
# 输出结果为 2.0 2.2
#混合类型的运算
1+2.0
# 输出结果为3.0
2+ (3.1+2j)
# 输出结果为 (5.1+2j)
a = 2**0.5
b = pow(2,0.5)
print(a,b)
# 开方
整型->浮点->复数，向着范围大的类型靠近
a=1
a+=2
print(a)
a%=2
print(a)
# 注意i++这种写法不能在python中使用
7.内置的内型转换函数
int(10.99)#转换规则是直接舍去小数点后的位数
round(10.99)#这个则是四舍五入
int(5.6E9)
# 5600000000
int('+9')
# 9
eval('9')
# 9
int()
# 0
float(10.5)
# 10
float(10)
# 10.0
float('10.1')
# 10.1
float()
# 0.0
float(1+2j)
#复数不能转换为浮点数
complex(0j)
# 0j
complex()
# 0j
complex(3,4)
3+4j
# 数学中类似求模长
abs(complex(3,4))
# 5.0
complex(3)
#虚部默认为0
# (3+0j)
a =2.0
b= 2
#会把b扩展为浮点型来比较
a==b
# True
0 == 0j
#整数的0是可以和复数的0j比较的，二者是相等的
# Ture
-1<0j #二者是不能相比较的
# 运算符优先级问题
print(-2**4*2)
# -32
8.字符串
type('abc')
# str
type('a')
#在python中单个字符也是str类型
# str
a = '"yes ",they said'
#单引号中能包含双引号
# '"yes ",they said'
a = "we're ready"
# 双引号中包含单引号
# "we're ready"
'we\'re ready'
# 使用转义字符来使用两个单引号
# "we're ready"
a = '''
abc
efg
'''
print(a)
# 可以输出，可以当注释
切片
开头第一个是0
#切片
s = "abcdefg"
s[1:3]# 从1开始取不包括3
# bc
s[1:]#从1开始取到最后1个
# bcdefg
s[:3]#从第0个开始取到第2个
# abc
s[:]#前后都不取表示全都切从零开始到最后
# abcdefg
字符串相关操作
下标索引
s = "abcdefg"
s[-1]
# -1表示最后一个
# 'g'
拼接
'a'+'b'
# 'ab'
# 'a'+1字符串不能和其他类型相加
'a'+'1'
# 'a1'
'go'*3#字符串的乘法表示将字符串连续重复三次
3*'abc'
# 'abcabcabc'
a = 0 *'abc'#字符串乘零过后出现的是空字符串
type(0*'abc')#同样是字符串类型
# str
输出星期天
s = '日一二三四五六'
n=0
weak = '星期'
weakday= weak+s[n%7]
print(weakday)
'a' in 'abc'#表示a是不是abc的子串
# True
'he' in 'hello world'
# True
s = len("abc")
# 3
字符串转为整型
int('8')
# 8
a=str(8)
b=str(1.1)
print(a,b)
print(type(a),type(b))
print("0")
print(type(str(0)))
输出为
8 1.1
<class 'str'> <class 'str'>
0
<class 'str'>
'a'+str(123)
# 'a123'
a = hex(123)#将一个数字转为十六进制数
print(type(a))
# <class 'str'>
a = oct(9)#将一个数字转为八进制数
print(a)
print(type(a))
"""
0o11
<class 'str'>
"""
chr、ord
chr(65)
# 'A'
ord('A')
# 65
星座
chr(25105)
chr(9800)
for i in range(12):
print(chr(9800+i))
♈
♉
♊
♋
♌
♍
♎
♏
♐
♑
♒
♓
s = '-3,4'
# x = -3 , y = 4
x,y = eval(s)
print(x,y)s = '-3,4'
# x = -3 , y = 4
x,y = eval(s)
print(x,y)
# -3 4
字符串的格式化
'ABC'.lower()
#大小写转换
'ABC'.islower()
#判断是否为小写
# False
' '.isspace()
' \t\n\v\r\f'.isspace()
#包含空格和空白字符
#判断是否为空格
# True
replace
'2024-03-31'.replace('-','/')
# \会被当作转义字符从而导致报错，所以我可以加两个转义字符
print('2024-03-31'.replace('-','\\'))
#将字符串中的某一种字符替换为另一种字符
print('2024-03-31'.replace('-',' '))
#也可以使用replace删除掉字符串中的字串
2024\03\31
2024 03 31
split join
'1,2,3,4,5'.split(',')
#分割过后返回的是一个列表，但是这个列表中的每一个元素是一个字符串
#在','处分割
['1', '2', '3', '4', '5']
ls = 'c d b a'.split(' ')
ls = sorted(ls)
' '.join(ls)
# 对cdba按空格进行分割，通过sorted排序后，再通过空格连接这个字符串
'a b c d'
'/'.join('2024-03-31'.split('-'))
'2024/03/31'
输出
a= 3.1415
print(a)
print(f"{a}")
print("{}".format(a))
print("%.4f" % a)
3.1415
3.1415
3.1415
3.1415
name = '张三'
age =20
h = 1.75123
print(f"{name}同学,{age}岁，身高为{h}米")
print("{}同学,{}岁，身高为{}米".format(name,age,h))
print("{1}同学,{0}岁，身高为{2}米".format(age,name,h))
print("{1}同学,{0}岁，身高为{2:.2f}米".format(age,name,h))
print(f"{name}同学,{age}岁，身高为{h:.2f}米")
print(f"{name}同学,{age+1}岁，身高为{h:.2f}米")
#format中可以改变编号,默认为0123…………排序
填充
print('{:-^30}'.format('python'))
#{:填充内容填充方式填充宽度}
print('{:,<30}'.format('python'))
print('{:,>30}'.format('python'))
print(f"{'python':_>50}")
------------python------------
python,,,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,python
____________________________________________python
进制输出
"{0:b},{0:d},{0:x},{0:c}".format(65)
#输出65表示的二进制，十进制，十六进制，和字符
'1000001,65,41,A'
"{0:.2f},{0:e},{0:.2%}".format(3.14159)
#保留小数位数，科学计数法，转化为百分比数
# 字典序排序
print('abcd'<'abc')
# 空串就是最小的
print(''<'a')
False
True
9.函数
基本使用
设置默认值可不写该参数
def knock_door(sound,times):
print(sound*times)
knock_door("咚",5)
# 咚咚咚
**设置默认值也可以传递一个值 **
def knock_door(sound,times=3):
print(sound*times)
knock_door("咚")
# 咚
求n!//m
def fact(n,m):
s=1
for i in range(1,n+1):
s*=i
i+=1
return s//m
n=int(input())
m=int(input())
a=fact(n,m)
print(a)
可变参数
a表示可变数量参
def getsum(s,*a):
print(type(a))
print(a)
for i in a:
s+=i
return s
# 相当于i会 遍历后面所有的数全部加到s上
a=getsum(10,1,2,3)
b=getsum(10)
print(a,b)
输出结果
<class 'tuple'>
(1, 2, 3)
<class 'tuple'>
()
16 10
可变参数求平均值
def avg(*a):
s=0
for i in a:
s+=i
return s/len(a)
a=avg(100,87)
print(a)
# 93.5
print函数扩展
name ='jim'
#传多个参数，中间默认有一个空格参数
print(1,2,3,name)
# 1 2 3 jim
name ='jim'
#传多个参数，中间默认有一个空格参数
print(1,2,3,name,sep = ',')
# 1,2,3,jim
位置传递
import math
def v(r,h):
return r**2*h*math.pi
r=3
h=4
# 位置传递，根据函数参数位置传递值
a=v(r,h)
print(a)
import math
def v(r,h):
return r**2*h*math.pi
#避免参数出错
a=v(r=3,h=4)
print(a)
#即使交换顺序了，结果还是一样的
a=v(h=4,r=3)
print(a)
返回值
#无返回值函数
def score_p(verbal,math,english):
print(f"verbal:{verbal},math:{math},english:{english}")
score_p(english=150,verbal=110,math=99)
# 两个返回值函数
#divmod返回的是函数的商和余数
a,b=divmod(10,3)
ans=divmod(10,3)
print(a,b,type(ans))
def n_s(n,s):
return n,s;
a,b=n_s(1,3)
ans=type(n_s(1,3))
print(a,b,ans)
"""
3 1 <class 'tuple'>
1 3 <class 'tuple'>
"""
#自己创一个divmod函数
def my_divmod(a,b):
return a//b,a%b;
a=my_divmod(10,3)
print(a)
# (1,3)
#零返回值
def knock_door(sound,times):
print(sound*times)
k=knock_door("咚",5)
#返回值为NONE
print(k)
"""
咚咚咚咚咚
None
"""
# 内置函数sum求和
# 在定义标识符的时候，不要将内置的函数给覆盖了
print(sum([1,2]))
# 3
10.高阶函数
对于以下这个函数
def calculate(a,b,op):
if op=='+':
c=a+b
elif op=='-':
c=a-b
elif op=='%':
c=a%b
return c
calculate(10,3,'%')
倘若我需要再加上一个乘操作，我是否需要，修改原函数，再加上一个elif？
def add(a,b):
return a+b
def multiply(a,b):
return a*b
def calculate(a,b,f):
return f(a,b) # 返回的是实参
# 其中写函数名表示这个函数
calculate(10,3,add)
calculate(10,3,multiply)
高阶函数就是可以接收其他函数的函数,其中f在传实参的时候只需要写函数名即可
print(type(print))
# 内置函数或者方法类型
# <class 'builtin_function_or_method'>
print(type(add))
# 函数类型，不过这里是我自己定义的函数也是函数类型
# <class 'function'>
可以将函数用来传递为自己定义的一个名字的函数用来调用
my_print=print
my_print(1,2,3)
# 1 2 3
lambada匿名函数
# 括起来作为一个整体用来调用
(lambda a,b:a+b)(10,3)
# 这里调用结束后，就不能再次调用了，这里就是一个临时的调用而已
# 13
add = lambda a,b:a+b
# 可以将lambda赋值给一个变量add，这下这个add会成为一个函数，可以通过变量add去调用这一个函数，可以反复的进行调用
"""
相当于
def add(a,b):
return a+b
"""
add(10,3)
# 13
通过lambda函数来使用高阶函数，从而避免了
我需要事先定义这个函数，在一些简单的操作定义
的时候可以这样实现
def add(a,b):
return a+b
def multiply(a,b):
return a*b
def calculate(a,b,f):
return f(a,b) # 返回的是实参
# 其中写函数名表示这个函数
calculate(10,3,lambda a,b:a%b)
# 1
# 实现平方和
squre= lambda a,b:a**2+b**2
squre(2,2)
calculate(3,4,squre)
# 25
sorted内置函数
默认升序排列
nums= [4,-8,3,-2,1]
sorted(nums)
# [-8, -2, 1, 3, 4]
可以在sorted中定义排序的规则，类似于c++中的
sort()
# 通过绝对值规则比较大小
nums= [4,-8,3,-2,1]
sorted(nums,key= lambda x:abs(x))
# [1, -2, 3, 4, -8]
#通过长度的规则对字符串排序
letter=['abc','a','of','hello']
# 默认按照字典序排序
sorted(l,key=lambda x:len(x))
# ['a', 'of', 'abc', 'hello']
map内置函数
nums=[1,2,3,4,5]
m=map(lambda x:x*x,nums)
# 通过for循环取出m中的每一个元素
# 但是不能够直接取出来，需要通过for循环来取出
for num in m:
print(num,end=' ')
# 1 4 9 16 25
nums=[1,2,3,4,5]
m=map(lambda x:x*x,nums)
# 通过将他强制转换为一个列表输出
ls=list(m)
print(ls)
# [1, 4, 9, 16, 25]
nums=[1,2,3,4,5]
def fact(n):
s=1
for i in range(1,n+1):
s*=i
return s
# 求阶乘映射到nums上
list(map(fact,nums))
# [1, 2, 6, 24, 120]
s= "1,2,3,4,5,6"
#[1,2,3,4,5,6]
# map接收的第二个参数为列表，可以通过split切分字符串，返回值为一个列表,列表中的每一个值为一个字符串
# int()可以将一个字符串转为相对应的整型
n=map(int,s.split(","))
list(n)
字符串的切割方法split，返回的是一个列表
s= "1,2,3,4,5,6"
s.split(",")
# ['1', '2', '3', '4', '5', '6']
转化为数值
s = "1.23 5 10 -5.1 -10 3e5"
# eval转化一个数值
n = map(eval,s.split(" "))
list(n)
# [1.23, 5, 10, -5.1, -10, 300000.0]
s = "1.23 5 10 -5.1 -10 3e5"
n = map(float,s.split(" "))
list(n)
# [1.23, 5.0, 10.0, -5.1, -10.0, 300000.0]
函数递归
阶乘
def fact(n):
if n==1 or n==0:
return 1
else:
return n*fact(n-1)
n = int(input())
fact(n)# n!=n*(n-1)!
def fact(n):
# 紧凑结构
return 1 if n==0 else n*fact(n-1)
n = int(input())
fact(n)# n!=n*(n-1)!
斐波那契数列
def fib(n):
# 从第0项开始
if n==0 or n==1:
return 1
else:
return fib(n-1)+fib(n-2)
反向打印字符串
def reverse_print(s):
if s == '':
return
print(s[-1],end='')
reverse_print(s[:-1])# 从首字母到倒数第二个
reverse_print("abcdefg")
# gfedcba
全局声明global
# 统计当下还能订多少票
available = 100
def book_tickets(n):
global available # 需要事先声明
available -=n # availabe=available-n
if available>=0:
print(f"剩余{available}张票")
else:
print("超售")
book_tickets(10)
book_tickets(20)
book_tickets(80)
剩余90张票
剩余70张票
超售
11.循环
for
for i in range(5):# 0 1 2 3 4
print(i)
0
1
2
3
4
for i in range(2,10,2):# 2 - 9 步长为2
print(i,end= ' ')
2 4 6 8
# -1表示从后面开始
for i in range(10,-1,-1):
print(i,end = ' ')
10 9 8 7 6 5 4 3 2 1 0
for i in range(10,-1,-2):
print(i,end = ' ')
10 8 6 4 2 0
word = 'hello'
for c in word:
print(c,end=' ')
#使用for遍历字符串
h e l l o
逆序
word = 'hello'
for i in range(len(word)-1,-1,-1):
print(word[i],end =' ')
o l l e h
遍历列表
ls = [5,-3,0,2,8]#遍历列表
for i in ls:
print(i,end= '')
print(' ')
for i in range(len(ls)):
print(ls[i],end = '')
5-3028
5-3028
while
a =64
while a:
print(a)
a//=2
64
32
16
8
4
2
1
a= input()
# 用while解决不确定循环次数的时候
while a!= 'n':
print(a)
a = input()
continue break
输出大于零的
ls = [5,-3,0,-2,8]#遍历列表
for i in ls:
if i<=0:
continue
print(i,end= ' ')# 打印正数
5 8
# 去点字符串的元音字母
a = 'disneyland'
s = 'aeiou'
for i in a:
if i not in s:
print(i,end = '')
dsnylnd
猜数字游戏
# 猜数字游戏
import random#随机库
answer = random.randint(0,9)#在这个范围内产生一个随机int 类型数字
# answer = 8
guess=int(input())
while guess!=answer:
if guess<answer:
print("猜小了")
else:
print("猜大了")
guess=int(input())
else:
print("猜对了")
1
猜小了
6
猜小了
8
猜对了
12.组合数据类型
基本类型，整型，浮点，复数，字符串
组合类型，将多个同类型或者不同类型的数据组织
起来，通过单一的表示使数据操作更加有序
可变和不可变划分
不可变类型:整型浮点复数字符串元组
可变类型:列表，字典，集合
通过序列下标访问字符串、列表和元组
列表
列表可以嵌套
a = [1,'abc',[2,3],4,5,5+6j]
print(a)
[1, 'abc', [2, 3], 4, 5, (5+6j)]
print(a[-1])
print(a[2])
# 取列表中嵌套的列表的元素
print(a[2][0])
# 取从第一个到最后一个元素
print(a[1:])
# 取从第一个到第三个元素
print(a[1:4])
# 判断1是否在a列表中返回ture否则false
print(1 in a)
# 判断abcd不在a列表中返回ture否则false
print("abcd" not in a)
(5+6j)
[2, 3]
2
['abc', [2, 3], 4, 5, (5+6j)]
['abc', [2, 3], 4]
True
True
a1=[1,2]
a2=[1,2,3]
# 判断a1和a2是否相等
print(a1!=a2)
# 元素个数多的会更大
a1=[1,2]
a2=[1,1,3]
print(a1>a2)
# 判断a1和a2的大小
a1=[1]
a2=[2]
print(a1<a2)
True
True
True
a=[1,2,3]
# 创建一个空列表
a=list()
print(a)
b=list('abcdef')
print(b)
# range的返回值为一个range对象，通过list将range的遍历元素变为列表
c=list(range(5))
print(c)
c1=[1,2,3]
c2=c1
# 这里改变了c1但是c2也进行了改变，说明二者指向的是同一个对象
c1.append(4)
print(c1)
print(c2)
[]
['a', 'b', 'c', 'd', 'e', 'f']
[0, 1, 2, 3, 4]
[1, 2, 3, 4]
[1, 2, 3, 4]
# id返回c1的地址
# 说明二者指向的同一个对象
print(id(c1))
print(id(c2))
# 判断c1是不是c2，判断是否指向同一个对象
# 和==判断不同，==只是判断二者的值是否相同
print(c1 is c2)
f1=[1,2,3]
f2=[1,2,3]
# 尽管f1和f2值相同，但是不是指向的同一个地址故is判断为false
print(f1==f2)
print(f1 is f2)
1772182703232
1772182703232
True
True
False
a=[1,2]
a[0]=0
print(a)
# 在列表后添加一个元素
a.append(3)
print(a)
a.append(4)
print(a)
# 通过切片的方式来修改其中的值
a[1:3]=[5,6]
print(a)
# 删除
del a[1:3]
print(a)
# 在a的后面加上元素
a+=[1,2]
print(a)
# extend和append的区别
a.extend([5,6])
print(a)
# extend 后面相当于拼接了元素在列表后面
# append 后面的参数代表添加这一个整体添加进了列表
a.append([5.6])
print(a)
[0, 2]
[0, 2, 3]
[0, 2, 3, 4]
[0, 5, 6, 4]
[0, 4]
[0, 4, 1, 2]
[0, 4, 1, 2, 5, 6]
[0, 4, 1, 2, 5, 6, [5.6]]
a = [1,2,3]
# insert(i,x)在第i个位置插入元素x
a.insert(1,5)
print(a)
# pop（i)取出第i个位置的元素，并且删除
b=a.pop(1)
print(a)
print(f"打印的b：{b}")
# 不带参数默认取出最后一个元素
# 可以将这个列表当作栈使用，先进先出后进后出
a.pop()
print(a)
# remove(x)删除元素x
a.remove(1)
print(a)
a=[1,2,3,1]
# 当存在多个相同元素时候，会删掉第一个元素
a.remove(1)
print(a)
# 反转数组reverse()
a.reverse()
print(a)
# copy()复制一份列表，
b=a.copy()
print(b)
# 只是复制了一份，二者不是同一个对象
print(a is b)
# 清空clear()
a.clear()
print(a)
[1, 5, 2, 3]
[1, 2, 3]
打印的b：5
[1, 2]
[2]
[2, 3, 1]
[1, 3, 2]
[1, 3, 2]
False
[]
a = [1,2,3,4]
a1=a[1:3]
print(a1)
# 将a从头到尾取出来赋值给a1
a1=a[:]
print(a1)
# 这里同样是产生了两个列表对象
print(a is a1) # 区分a1==a
print(a==a1)
[2, 3]
[1, 2, 3, 4]
False
True
a = [1,2]
print(id(a))
a*=3
print(a)
print(id(a))
# 这里发现a的id并没有改变，只是a中的值发生了改变而已，地址没有改变
1772182958912
[1, 2, 1, 2, 1, 2]
1772182958912
c='abc'
print(id(c))
c*=3
print(id(c))
# 由于字符串是不可变类型，故这时候不是同一个对象了
140708449642288
1772182925744
# 空列表
a=[]
print(a)
print(id(a))
a *=3
print(a)
print(id(a))
[]
1772182874880
[]
1772182874880
a=[[]]
print(a)
# 将*表示列表中的元素重复三次
a*=3
print(a)
[[]]
[[], [], []]
# 发现使用了apped后影响了后面的元素
a[0].append(1)
print(a)
[[1], [1], [1]]
# 手写的空列表就不会影响
c=[[],[],[]]
c[0].append(1)
print(c)
[[1], [], []]
a=[1,2,3]
# 原地操作in-place
# 表示append没有返回值，默认返回值为none
print(a.append(4))
None
a = [1,2]
# 说明对象并没有改变
# 只是增加了一个元素
print(id(a))
a*=3
print(id(a))
1377612698688
1377612698688
s='a'
print(id(s))
s*=3
print(id(s))
140733771795544
1377611705648
元组
# 元组的创建
a1 = (1,2)
a2 = 3,4
print(a1)
print(a2)
(1, 2)
(3, 4)
# 元组作为函数返回值
print(divmod(10,3))
def f():
return 1,2,3
print(f())
(3, 1)
(1, 2, 3)
# 同步赋值
a= 1
b,c=2,3
print(a,b,c)
d=e=f=6
print(d,e,f)
x,y=1,2
x,y=y,x
print(x,y)
a=b=[]
1 2 3
6 6 6
2 1
注意
t= (1,2)
#t.append(3)是不对的
# 元组是不能够发生改变的
元组可变数量函数
def get_sum(s,*a):
print(type(a))
print(a)
for i in a:
s+=i
return s
get_sum(0,1,2,3)
<class 'tuple'>
(1, 2, 3)
创建一个空的元组
a = tuple()
a
b=()
print(type(a))
print(type(b))
<class 'tuple'>
<class 'tuple'>
t1 = (1,2,3)
t2 = tuple()
t = tuple(range(5))
print(t1,t2,t)
(1, 2, 3) () (0, 1, 2, 3, 4)
元组的嵌套
t=((1,2,3),[1,2,3],"hello world")
# 对元组中嵌套的列表来改变列表里面的值间接改变元组的值
# 但是元组中的每一个对象仍然是没有发生改变的，仍然是原来指向的对象，元组的不可变的性质仍然是成立的
t[1].append(4)
print(t)
((1, 2, 3), [1, 2, 3, 4], 'hello world')
集合
集合用中括号表示
d ={(1,2):1,(3,4):2}
d
{(1, 2): 1, (3, 4): 2}
集合中添加元素
s = {1,2}
s.add(3)
{1, 2, 3}
集合中删除元素
s={1, 2, 3}
s.remove(3)
s
{1, 2}
s={1,2,3}
s.discard(5)
# 即使没有这个元素也不会发生报错
print(s.discard(5))
s.discard(2)
print(s)
None
{1, 3}
s= {1,2,3}
# 随机删除s中的一个元素
p = s.pop()
print(p)
print(s)
1
{2, 3}
清空
# 清空s
s.clear()
s
set()
判断某个元素是否属于这个集合
# 判断某个元素是否属于这个 集合
s = {1,2,3}
print(2 in s)
集合在数学中的运算
交集
s ={1,2,3,4}
t = {3,4,5,6}
# s和t的交集
# 两种表达方式
# 发现并没有生成新的集合，因为id是相同的
# intersection 产生的二者的交集为临时变量
print(s&t)
print(id(s))
print(s.intersection(t))
print(id(s))
{3, 4}
1758450656736
{3, 4}
1758450656736
并集
# 并集
s ={1,2,3,4}
t = {3,4,5,6}
print(s | t)
{1, 2, 3, 4, 5, 6}
减
# 减
s ={1,2,3,4}
t = {3,4,5,6}
print(s-t)
{1, 2}
补集
# 补集
s ={1,2,3,4}
t = {3,4,5,6}
s^=t
print(s)
子集
#判断是否为子集
s ={1,2,3,4}
t = {3,4,5,6}
s1 ={1,2}
print(s1 <=s )
True
字典
映射
键值对
键-值（key,value）
**字典是没有顺序的 **
创建
d={'apple':'苹果','school':'学校','China':'中国'}
print(d)
{'apple': '苹果', 'school': '学校', 'China': '中国'}
利用索引一个键来找出他的值
d['apple']
'苹果'
区别列表
列表是用数字来表示索引
i=[1,2,3,4]
i[1]
# 2
字典的创建
a = {'a':1,'b':2,'c':3}
print(a)
{'a': 1, 'b': 2, 'c': 3}
a={}
print(a)
print(type(a))
# 字典的类型为dict
{}
<class 'dict'>
a1 = dict(a)
# 是两个不同对象
print(a1 is a)
print(a1)
False
{}
zip
# dict()
x= ['c','a','b']
y=[1,3,2]
list(zip(x,y))
[('c', 1), ('a', 3), ('b', 2)]
也可以这样打包成一个列表
d1=dict([('c', 1), ('a', 3), ('b', 2)])
print(d1)
d2 = dict(list(zip(x,y)))
print(d2)
{'c': 1, 'a': 3, 'b': 2}
{'c': 1, 'a': 3, 'b': 2}
关键字参数创建字典
d3 = dict(a=3,c=1,b=2)
# d3 = dict(‘a’=3,'c'=1,'b'=2) 错误
print(d3)
{'a': 3, 'c': 1, 'b': 2}
字典的操作
修改
d={'apple':'苹果','school':'学校','china':'中国'}
d['china'] = '瓷器'
print(d)
{'apple': '苹果', 'school': '学校', 'China': '中国', 'china': '瓷器'}
增加
d['university']='学校'
# 解释器会进行判断，倘若字典里有这个university那么会修改其对应的值，倘若没有，那么增加这一个university键值对
print(d)
{'apple': '苹果', 'school': '学校', 'China': '中国', 'china': '瓷器', 'university': '学校'}
添加update
dd={}
dd['a']=3
dd.update({'d':5,'e':6})
{'a': 3, 'd': 5, 'e': 6}
# 或者进行更新
dd.update({'a':4})
print(dd)
# 进行添加
dd.update({'f':9})
print(dd)
{'a': 4, 'd': 5, 'e': 6}
{'a': 4, 'd': 5, 'e': 6, 'f': 9}
d1 = {'a':[1,2],'b':[3,4]}
d2 = d1.copy()
print(d2)
# 在这里 修改了d1但是d2的值也是增加了
# 可是这里的d1和d2是两个不同的对象
d1['a'].append(3)
print(d2)
print(f"d1和d2相同对象吗？{d1 is d2}")
{'a': [1, 2], 'b': [3, 4]}
{'a': [1, 2, 3], 'b': [3, 4]}
d1和d2相同对象吗？False
这里发现修改了d1但是d2发生了改变为了解决这样问题，利用深拷贝
import copy
d1 = {'a':[1,2],'b':[3,4]}
d2 = copy.deepcopy(d1)
d1['a'].append(3)
print("d2的元素为:\n")
print(d2)
print("d1的元素为:\n")
print(d1)
print(f"d1和d2相同对象吗？{d1 is d2}")
d2的元素为:
{'a': [1, 2], 'b': [3, 4]}
d1的元素为:
{'a': [1, 2, 3], 'b': [3, 4]}
d1和d2相同对象吗？False
字典定义类型的方法
# 定义一个字典d
d={'apple': '苹果', 'school': '学校', 'China': '中国', 'china': '瓷器', 'university': '学校'}
keys()
print(d.keys())
dict_keys(['apple', 'school', 'China', 'china', 'university'])
values()
print(d.values())
dict_values(['苹果', '学校', '瓷器', '学校'])
items()
print(d.items())
dict_items([('apple', '苹果'), ('school', '学校'), ('china', '瓷器'), ('university', '学校')])
放在for循环中
for key in d.keys():
print(key,end=' ')
print('\n')
for value in d.values():
print(value,end=' ')
print('\n')
for item in d.items():
print(item,end=' ')
print('\n')
apple school china university
苹果 学校 瓷器 学校
('apple', '苹果') ('school', '学校') ('china', '瓷器') ('university', '学校')
直接遍历字典相当于d.keys(),遍历出来的是字典中的键
for key in d:
print(key,end=' ')
apple school china university
字典中的键不能够重复但是值可以重复
字典转为列表
print(list(d.keys()))
print(list(d.values()))
print(list(d.items()))
['apple', 'school', 'china', 'university']
['苹果', '学校', '瓷器', '学校']
[('apple', '苹果'), ('school', '学校'), ('china', '瓷器'), ('university', '学校')]
get访问键对用的值
print(d.get('apple'))# d['apple']
#区别,可以设置默认值
print(d.get('man','男人'))
苹果
男人
pop()
d1 =dict(d)
# 会返回相对的值，同时在d中删除了apple
a1 = d.pop('apple')
print(d)
{'school': '学校', 'china': '瓷器', 'university': '学校'}
随机删除一个值popitem
v2 = d.popitem()
print(v2)
print(d)
('china', '瓷器')
{'school': '学校'}
扫一扫
4883
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
