遍历字典

keys() 返回字典的所有的key

d={'name':'葫芦娃','age':'7','gender':'男'}

for k in d.keys():

print(k) #name,age,gender

values() 返回字典的所有的key所对应的值

d={'name':'葫芦娃','age':'7','gender':'男'}

for v in d.values():

print(v) # 葫芦娃，7，男

items() 返回字典中所有的项，返回值是⼀个序列

d={'name':'葫芦娃','age':'7','gender':'男'}

for i in d.items():

print(i) #('name', '葫芦娃')，('age', '7')，('gender', '男')

集合

集合的特点

1.只能存储不可变对象

2.存储的对象是无序的(不是按照元素的插入顺序来保存）

3.不能出现重复的元素

4.表现形式为{}

# s = {1,2,3,4}

# print(s,type(s)) #集合的类型

# s = {10,1,2,3,4}

# print(s,type(s)) #集合的无序性

# s = {100,10,1,2,3,4}

# print(s,type(s)) #集合的无序性

# s = {100,10,1,2,3,4,1,2,3,4}

# print(s,type(s)) ##集合的不重复性

# s={[1,2,3],[4,5,6]}

# print(s,type(s))#TypeError: unhashable type: 'list'

# s={(1,2,3,4,5,6)}

# print(s,type(s)) #集合的不可变对象性

# s={}

# print(s,type(s)) #{}为空是字典类型

# s={1,2}

# print(s,type(s)) #{}不为空是集合类型

# s=set() #创建一个集合

# print(s,type(s))

#s=set(1,2,3)

# print(s,type(s)) #TypeError: set expected at most 1 arguments, got 3

#s=set(1)

#print(s,type(s)) #TypeError: 'int' object is not iterable

# s=set('hello')

# print(s,type(s)) #创建的集合对象必须是可迭代的

s={'a','b',1,2,3}

# print(s,type(s)) #集合中的元素是无序的所以不能使用下标来索引

#print(s[0])#TypeError: 'set' object does not support indexing

集合的方法

set() 将序列和字典转换成集合

# s=set([1,2,3,4,5,6])

# print(s,type(s))

len() 获取集合中元素的数量

s = {1,2,3,4}

print(len(s)) #4

add() 向集合中添加元素

s = {1,2,3,4}

s.add(5)

print(s) #{1，2，3，4，5}

update() 将⼀个集合中的元素添加到另⼀个集合当中

s={'a','b',1,2,3}

s2=set('hello')

s.update(s2)

print(s) #{1, 2, 3, 'h', 'a', 'o', 'e', 'l', 'b'}

pop() 随机删除集合中的⼀个元素

#一般是删除最后一个元素，并返回该删除的元素

s={'a','b',1,2,3}

r=s.pop()

print(r) #2

print(s) #{'a','b',1,3}

remove() 删除集合中指定的元素

s={'a','b',1,2,3}

s.remove(1)

print(s) #{'a','b',2,3}

clear() 清空集合

s={'a','b',1,2,3}

s.clear()

print(s) #set()

集合的运算

1.& 交集运算(两个集合中相同的元素)

2.| 并集运算（两个集合合并，并覆盖相同元素）

3.- 差集运算 （一个集合对另一个集合做差，所得为另一个集合中不存在此集合的元素部分）

4.^ 亦或集 （两集合中除相同元素外的其他元素合集）

5.<= 检查⼀个集合是否是另⼀个集合的⼦集

6.< 检查⼀个集合是否是另⼀个集合的真⼦集

7.>=检查⼀个集合是否是另⼀个集合的超集

8.>检查⼀个集合是否是另⼀个集合的真超集

函数（一）

概念

#函数也是一个对象

#对象是内存中专门用来存储数据的一块区域

#函数⽤来保存⼀些可执⾏的代码，并且可以在需要时，对这些语句进⾏多次调⽤

#定义一个函数

def fn():

print('这是我的第一个函数')

# fn()

# fn() #可多次调用

# fn()

# fn()

#print(fn)#

#fn是函数对象 fn()调用函数

print(fn)#

print(fn())#这是我的第一个函数

参数

#在定义函数的时候，可以在函数后边的括号中定义数量不等的形参

#多个形参之间要用，隔开

#有几个形参就得传递几个实参

def s(a, b):

print(a + b)

s(2, 3)

参数的传递方式

#在定义函数的形参的时候，可以指定一个默认值

# def fn(a,b,c=20):

# print('a=',a)

# print('b=',b)

# print('c=',c)

# fn(1,2,3) #1,2,3

# fn(1,2) #1,2,20

#函数的传递方式

#位置传参（对应的形参位置，传递对应实参位置）

#关键字传参（可以不按照定义的顺序来传递，它是根据参数的名字来传递）

# def fn(b=1,c=2,a=3):

# print('a=', a)

# print('b=', b)

# print('c=', c)

# fn() #a=3，b=1，c=2

#混合使用时，关键字传递在位置传递后边

# def fn(c=2,a):

# print('a=', a)

# print('c=', c)

# fn(1)#SyntaxError: non-default argument follows default argument

可变对象

#对象在内存中都保存了三个数据

#id(标识)

#type（类型）

#value（值）

'''

a=[1,2,3]

a

[1, 2, 3]

a[0]=10

a

[10, 2, 3]

a=[4,5,6]

a

[4, 5, 6]

列表是一个可变对象

a=[1,2,3]

a[0]=10(改对象里面的value)

这个操作是在通过变量去修改对象的值

这个操作不会改变变量所指向的对象

a=[4,5,6](改变量，改对象里面的value，同时还有id)

这个操作是在给变量重新赋值

这个操作会改变量所指向的对象

'''

a=[1,2,3]

b=a

b[0]=10

print('a',a,id(a)) #a [10, 2, 3] 1826753172040

print('b',b,id(b)) #b [10, 2, 3] 1826753172040

a=[1,2,3]

b=a

#b[0]=10

b=[10,2,3]

print('a',a,id(a)) #a [1, 2, 3] 1826753172616

print('b',b,id(b)) #b [10, 2, 3] 1826753172040

实参的类型

def fn(b=1, c=2, a=3):

print('a=', a)

print('b=', b)

print('c=', c)

def fn2(a):

print('a=', a)

b = 123

b = True

b = 'hello'

b = None

fn2(fn) #实参的类型可以是任意对象

def fn3(a, b):

print(a + b)

fn3(123, 456)

fn3(123, '456') # TypeError: unsupported operand type(s) for +: 'int' and 'str'

def fn4(a):

print('a=',a) #10

c=10

fn4(c)

print('c=',c) #10

#在函数中对形参重新赋值，不会影响其他的变量

def fn5(a):

a=20

print('a=',a) #a=20

c=10

fn5(c)

print('c=',c) #c=10

#指向同一个对象

def fn6(a):

a[0]=30

print('a=', a,id(a))#a= [30, 2, 3] 1776475329096

c = [1, 2, 3]

fn6(c)

print('c=', c,id(c))#c= [30, 2, 3] 1776475329096

#浅复制指向不同对象

def fn7(a):

a[0]=30

print('a=', a,id(a))#a= [30, 2, 3] 2493401027720

c = [1, 2, 3]

fn7(c.copy())

print('c=', c,id(c))#c= [1, 2, 3] 2493401027144

#列表切片也指向不同对象

def fn8(a):

a[0]=30

print('a=', a,id(a))#a= [30, 2, 3] 2210691896456

c = [1, 2, 3]

fn8(c[:])

print('c=', c,id(c))#c= [1, 2, 3] 2210691895880

原文链接:https://blog.csdn.net/weixin_43232381/article/details/108410054

本文链接：https://my.lmcjl.com/post/6306.html