Python列表
访问列表中的值
1.索引
2.反向索引
索引也可以从尾部开始，最后一个元素的索引为-1，往前一位为-2，以此内推。
list = ['red', 'green', 'blue', 'yellow', 'white', 'black'] print( list[-1] ) #black print( list[-2] ) #white print( list[-3] ) #yellow
3.切片索引
使用下标索引来访问列表中的值，同样也可以使用方括号[]的形式截取字符
注：切片是浅拷贝操作
nums = [10, 20, 30, 40, 50, 60, 70, 80, 90] print(nums[0:4]) #[10, 20, 30, 40] list = ['openAI', 'hqyj', "Zhihu", "Taobao", "Wiki"] print (list[1]) #hqyj print (list[1:-2]) #['hqyj', 'Zhihu'] print (list[2:]) #['Zhihu', 'Taobao', 'Wiki'] print (list[:3]) #['openAI', 'hqyj', 'Zhihu']
更新列表
对列表的数据项进行修改或更新，也可以使用append()方法来添加列表项
list = ['openAI', 'hqyj', 1997, 2000]
print (list[2]) #1997
list[2] = 2001
print (list[2]) #2001
list1 = ['openAI', 'hqyj', 'Taobao']
list1.append('Baidu')
print (list1) #['openAI', 'hqyj', 'Taobao', 'Baidu']
删除列表元素
使用del语句来删除列表元素
list = ['openAI', 'hqyj', 1997, 2004] print (list) del list[2] print (list) ''' ['openAI', 'hqyj', 1997, 2004] ['openAI', 'hqyj', 2004] '''
列表操作符
嵌套列表
使用嵌套列表即在列表里创建其他列表
a = ['a', 'b', 'c'] n = [1, 2, 3] x = [a, n] print(x)#[['a', 'b', 'c'], [1, 2, 3]] print(x[0])#['a', 'b', 'c'] print(x[0][1])#b
python列表常用API
- len(list)列表元素个数
- max(list)返回列表元素最大值
- min(list)返回列表元素最小值
- list(seq)将元组转换为列表
- list.append(obj)在列表末尾添加新的对象
- list.count(obj)统计某个元素在列表中出现的次数
- list.extend(seq)在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
- list.index(obj)从列表中找出某个值第一个匹配项的索引位置
- list.insert(index, obj)将对象插入列表
- list.pop(index=-1)移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
- list.remove(obj)移除列表中某个值的第一个匹配项
- list.reverse()反向列表中元素
- list.sort( key=None, reverse=False)对原列表进行排序: x.sort(key=lambda a:abs(a-3), reverse=False)
- list.clear()清空列表
- list.copy()复制列表
Python元组
创建元组
python的元组与列表相似，不同之处在于元组的元素不能修改
元组使用小括号（），列表使用方括号[]
元组可以存放相同类型的数据、不同类型的数据和不需要括号也行
tup1 = (1, 2, 3, 4, 5 ) tup2 = ( 'hqyj', 2004) tup3 = "a", "b", "c", "d"
当元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当做运算符使用
tup1 = (50) tup2 = (50,)
访问元组
元组与字符串类似，下标索引从0开始，可以进行截取，组合等（不能进行修改）。
tup1 = ('python', 'hqyj', 100, 200)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
print (tup1[0])#python
print (tup2[1:5])#(2, 3, 4, 5)
print (tup2[:4])#(1, 2, 3, 4)
print (tup2[2:])#(3, 4, 5, 6, 7)
修改元组
元组中的元素值是不允许修改的，但可以对元组进行连接组合
tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
# 创建一个新的元组
tup3 = tup1 + tup2
print (tup3)
#(12, 34.56, 'abc', 'xyz')
# 以下修改元组元素操作是非法的。
# tup1[0] = 100
删除元组
元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组
tup = ('openAI', 'hqyj', 100, 200)
print (tup)
del tup
print (tup)#name 'tup' is not defined
元组运算符
与字符串一样，元组之间可以使用+、+=和*号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。
元组常用API
Python字典
字典是一种可变容器模型，且可存储任意类型对象
字典的每个键值对（key:value）用冒号分割，每个对之间用逗号分割，整个字典包括在花括号{}中
d = {key1 : value1, key2 : value2, key3 : value3 }
创建字典
dict 作为 Python 的关键字和内置函数，变量名不建议命名为 dict。
键必须是唯一的，但值则不必。
值可以取任何数据类型，但键必须是不可变的，如字符串，数字。
d1 = {}#创建空字典
d2 = dict()#使用内建函数 dict()创建字典
d3 = {"name":"karen","age":23}
d4 = dict({"name":"jack","age":24})
print(d3)# 打印字典
print(len(d3))# 查看字典的数量
print(type(d3))# 查看类型
访问字典里的值
mydic = {'Name': 'hqyj', 'Age': 7, 'Class': 'First'}
print (mydic['Name'])#hqyj
print (mydic['Age'])#7
如果字典里没有的键访问数据，会输出错误
修改字典
向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对
mydic = {'Name': 'hqyj', 'Age': 7, 'Class': 'First'}
mydic['Age'] = 8 # 更新
mydic['School'] = "xxxxx" #添加信息
print (mydic['Age'])#7
print (mydic['School'])#xxxxx
删除字典元素
能删单一的元素也能清空字典，清空只需一项操作
显式删除一个字典用del命令
mydic = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
del mydic['Name'] # 删除键 'Name'
# mydic.clear() # 清空字典
print(mydic['Age'])
print(mydic['Class'])
del mydic # 删除字典
print(mydic)# name 'mydic' is not defined
字典键的特性
字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。
1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住
2）键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行
字典常用API
- len(dict) 计算字典元素个数，即键的总数。
- str(dict) 输出字典，可以打印的字符串表示。
- type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型。
- dict.clear()删除字典内所有元素
- dict.copy()返回一个字典的浅复制
- dict.fromkeys()创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
- dict.get(key, default=None)返回指定键的值，如果键不在字典中返回 default 设置的默认值
- key in dict如果键在字典dict里返回true，否则返回false
- dict.items()以列表返回一个视图对象
- dict.keys()返回一个视图对象
- dict.setdefault(key, default=None)和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
- dict.update(dict2)把字典dict2的键/值对更新到dict里
- dict.values()返回一个视图对象
- pop(key,default)删除字典 key（键）所对应的值，返回被删除的值。
- popitem()返回并删除字典中的最后一对键和值。
Python集合
集合（set）是一个无序的不重复元素序列。
集合中的元素不会重复，并且可以进行交集、并集、差集等常见的集合操作。
创建集合
可以使用大括号 { } 创建集合，元素之间用逗号 , 分隔， 或者也可以使用 set() 函数创建集合
注：创建一个空集合必须用set()而不是{}，因为{}是用来创建一个空字典
parame = {value01,value02,...}
set(value)
set1 = {1, 2, 3, 4}# 直接使用大括号创建集合
set2 = set([4, 5, 6, 7])# 使用 set()函数从列表创建集合
set3 = set((4, 5, 6, 7))# 使用 set()函数从元组创建集合
添加元素
将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。
s.add( x ) 添加元素到集合 ,x 可以有多个，用逗号分开
s.update( x ) 添加元素到集合，且参数可以是列表，元组，字典等 ,x 可以有多个，用逗号分开
s1 = set((4, 5, 6, 7))
s1.add(100)
print(s1) #{100, 4, 5, 6, 7}
s1.update([200,300])
print(s1) #{100, 4, 5, 6, 7, 200, 300}
移除元素
s.remove( x ):将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。
s.discard( x ):将元素 x 从集合 s 中移除，如果元素不存在，不会发生错误。
s.pop():对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除。
计算集合元素个数
len(s):计算集合元素个数
清空集合
s.clear():清空集合
判断元素中 是否在集合中存在
x in s 判断元素 x 是否在集合 s 中，存在返回 True，不存在返回 False。
集合内置方法API
| 方法 | 描述 |
|---|---|
| add() | 为集合添加元素 |
| clear() | 移除集合中的所有元素 |
| copy() | 拷贝一个集合 |
| difference() | 返回多个集合的差集 |
| difference_update() | 移除集合中的元素，该元素在指定的集合也存在。 |
| discard() | 删除集合中指定的元素 |
| intersection() | 返回集合的交集 |
| intersection_update() | 返回集合的交集。 |
| isdisjoint() | 判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。 |
| issubset() | 判断指定集合是否为该方法参数集合的子集。 |
| issuperset() | 判断该方法的参数集合是否为指定集合的子集 |
| pop() | 随机移除元素 |
| remove() | 移除指定元素 |
| symmetric_difference() | 返回两个集合中不重复的元素集合。 |
| symmetric_difference_update() | 移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。 |
| union() | 返回两个集合的并集 |
| update() | 给集合添加元素 |
| len() | 计算集合元素个数 |
Python推导式
Python 推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体。
列表推导式
[表达式 for 变量 in 列表]
[表达式 for 变量 in 列表 if 条件]
[out_exp_res for out_exp in input_list if condition]
-
out_exp_res：列表生成元素表达式，可以是有返回值的函数。
-
for out_exp in input_list：迭代 input_list 将 out_exp 传入到 out_exp_res 表达式中。
-
if condition：条件语句，可以过滤列表中不符合条件的值。
-
original_list = [1, 2, 3, 4, 5] # 使用列表推导式创建一个新列表，包含原始列表中每个元素的平方 squared_list = [x ** 2 for x in original_list] print(squared_list) # 输出 [1, 4, 9, 16, 25]
字典推导式
{ key_expr: value_expr for value in collection }
{ key_expr: value_expr for value in collection if condition }
original_dict = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
# 使用字典推导式创建一个新字典，包含原始字典中每个键值对的值的平方
squared_dict = {key: value ** 2 for key, value in original_dict.items()}
print(squared_dict) # 输出 {'a': 1, 'b': 4, 'c': 9, 'd': 16, 'e': 25}
集合推导式
{ expression for item in Sequence }
{ expression for item in Sequence if conditional }
original_list = [1, 2, 3, 4, 5]
# 使用集合推导式创建一个新集合，包含原始列表中每个元素的平方
squared_set = {x ** 2 for x in original_list}
print(squared_set) # 输出 {1, 4, 9, 16, 25}
元组推导式
元组推导式可以利用 range 区间、元组、列表、字典和集合等数据类型，快速生成一个满足指定需求的元组。
元组推导式和列表推导式的用法也完全相同，只是元组推导式是用 () 圆括号将各部分括起来，而列表推导式用的是中括号 []，另外元组推导式返回的结果是一个生成器对象。
在 Python 中，元组推导式实际上并不存在。元组是不可变的数据结构，因此不能像列表推导式那样通过推导式来创建。
元组推导式基本格式：
(expression for item in Sequence )
(expression for item in Sequence if conditional )
# 使用 tuple() 构造函数创建元组 my_tuple = tuple([1, 2, 3, 4, 5]) print(my_tuple) # 输出 (1, 2, 3, 4, 5) # 直接用逗号分隔的方式创建元组 my_tuple = 1, 2, 3, 4, 5 print(my_tuple) # 输出 (1, 2, 3, 4, 5)
Python函数
定义函数
1.函数代码块以def关键词开头，后接函数标识名称和圆括号（）
2.任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
3.函数的第一行语句可以选择性使用文档字符串——用于存放函数说明。
4.函数内容以冒号：起始，并且缩进。
5.return[表达式]结束函数，选择性地返回一个值给调用方，不带表达式的return相当于返回None
def fn():
print('我是函数')
fn()
函数参数
python支持以下类型参数
1.必需参数：必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
def fn1(x):
print(x*2)
fn1(10)#20
def fn2(x,y):
print(x*2,y)
fn2(10,20)#20 20
def fn3(x,y):
print(x+y)
fn3(10)#报错
def fn4(x):
print(x*3)
fn4(10,20)#报错
2.默认参数：调用函数时，如果没有传递参数，则会使用默认参数, 默认参数必须写在必须参数后面。
def fn1(x,y=0):
print(x,y)
fn1(100)#100 0
def fn2(x=0,y=1):
print(x,y)
fn2()#0 1
#错误的函数设计
def fn3(x=0,y):
print(x,y)
3.可变参数：函数可以接受不定数量的参数。可以通过*args(接受任意数量是位置参数)和**kwargs(接受任意数量的关键字参数)来实现。
4.关键字参数：关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。
使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。
def fn1(x,y):
print(x,y)
fn1(100,y=200)#100 200
def fn2(x,y):
print(x,y)
fn2(y=100,x=200)#200 100
返回值
函数可以使用return语句来返回一个或多个值
如果没有明确的return语句，函数将默认返回None
#没有return
def fn1():
print("调用了函数")
re=fn1()
print(re)#None
#返回一个值
def fn2(x):
return x+100
re2=fn2(100)
print(re2)#200
#返回多个值
def fn3(x):
return x*x,x%3
re3=fn3(100)
print(re3)#(10000, 1)
x,y=fn3(100)
print(x,y)#10000 1
匿名函数
在python中，匿名函数通常使用lambda关键字来创建。匿名函数也被称为lambda函数，它是一种简单的、一行的函数，常用于临时需要一个小函数的地方。匿名函数的语法如下：
lambda arguments:expression
1.lambda是关键词，表示你正在定义一个匿名函数。
2.arguments是函数的参数，可以有零个或多个参数，参数之间用逗号分隔。
3.expression是函数的返回值，通常是一个表达式，匿名函数会计算这个表达式并返回结果。
# 定义一个匿名函数，计算两个数的和 add = lambda x, y: x + y # 调用匿名函数 result = add(3, 5) print(result) # 输出 8
高阶函数
高阶函数是指可以接受一个或多个函数作为参数，或者返回一个函数作为结果的函数。
返回一个函数作为结果的函数
def tool(arg):
def fn(x):
return x * x
def fn2(x):
return x % 9
if arg == 1:
return fn
else:
return fn2
func=tool(1)
print(func(100))
函数作为参数传递 ，高阶函数也可以接受其他函数作为参数，用于自定义行为。
def tool(arg, fn):
fn(arg % 2 == 1)
tool(1, lambda x: print(x))
tool(255, print)
扫一扫
385
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
