一.循环
1.if循环
-
语法
if 条件表达式1: 语句块1 elif 条件表达式2: 语句块2 elif 条件表达式3: 语句块3 ... elif 条件表达式n: 语句块n else: 语句块(其他)
2.while 语句
-
作用
根据一定的条件，重复的执行某个语句块
-
语法
while 真值表达式: 语句块1 (*此部分可能会重复执行) else: 语句块2
-
说明
-
else 子句可以省略
-
else 子句 当且仅当 真值表达式为假Flase的时候 会执行 else 里的语句块2
-
如果 此 while 是因为 调用 break 语句而终止循环。则 else 子句里的语句不会执行
-
-
示例1
while 1 < 2: print("hello world")再终端界面下 ctrl + c 可以终止正在执行的程序(进程)
-
示例2
# 打印 5 行 "hello world" i = 0 while i < 5: print("hello world") i = i + 1 # 也可写成 i += 1 else: print("while 语句已经结束!")
3.for循环
-
for语句作用
-
用来遍历可迭代对象的数据元素
遍历是指经历且只经历一遍
可迭代对象是指能够依次获取数据元素的对象
可迭代对象
-
字符串
-
---- 以下后面才讲----
-
列表 list
-
字典 dict
-
...
-
-
语法
for 变量列表 in 可迭代对象: 语句块1 else: 语句块2
-
语法说明
-
else 子句可以省略
-
else 子句的语句块2 只有在 可迭代对象不再能提供数据的时候才会执行
-
因为 语句块1 部分调用break 而终止循环式，else 子句部分不会执行。
-
-
示例
s = 'ABCDE' for ch in s: print('ch=', ch) else: print("遍历结束")
二.range函数
range 函数
-
作用
用来生成一个能够得到一系列整数的可迭代对象（也叫整数序列生成器）
-
调用格式
range(stop) # stop 停止整数 range(start, stop) # start 开始整数 range(start, stop, step) # step 步长
range 函数调用会生成从 start 开始，到 stop 结束(不包含stop) 的一系列整数，整数的间隔 step
start 默认值为0, step 默认值为1
-
示意
range(4) # 生成 0 1 2 3 range(3, 6) # 生成 3 4 5 range(1, 10, 2) # 生成 1 3 5 7 9 range(5, 0, -2) # 生成 5 3 1
三.break语句和continue语句
1.break语句
-
作用
用于循环语句(while, for语句)中, 当break 执行是，她会终止包含他的当前循环。
-
语法
break
-
说明
-
break 语句只能用在 while 语句或for语句的内部。
-
break 语句通常和 if 语句组合使用。
-
当break 语句执行后，此循环语句break 之后的所有语句都不会执行（else 子句里的语句也不执行）
-
break 语句只能终止包含他的当前循环，当有循环嵌套时，只能跳出离他最近的一个循环
-
-
示例
i = 1 while i <= 5: print('i=', i) if i == 2 break i += 1 else: print('循环结束: i=', i)
2.continue 语句
-
作用
用于循环语句(while 语句和for语句)中， 不再执行本次循环内 continue 之后的语句，开始一次新的循环
-
语法
continue
-
说明
-
在for 语句中, 执行continue 语句，for语句将会从可迭代对象向中获取下一个元素绑定变量后再次进行循环
-
在while 中,执行continue 语句, 将会直接跳转到while 语句的真值表达式处，重新判断循环条件。
-
-
示例1
for x in range(5): if x % 2 == 0: continue print(x) # 1 3
四.列表(list)
Python 支持多种复合数据类型，可将不同值组合在一起。最常用的列表 ，是用方括号标注，逗号分隔的一组值。列表可以包含不同类型的元素，但一般情况下，各个元素的类型相同
-
列表是一种可以存储任意个各种类型的序列容器
-
列表内的数据有先后顺序关系
-
列表是可变的容器
1.列表的创建
-
创建列表的字面值
>>> L = [] # 创建一个空的列表 >>> L = ['北京', '上海', '广州', '西安'] # 创建一个含有4个字符串的列表
注： python 中的 (), [], {} 和 三引号字符串都要成对出现, 可以换行
-
创建列表的构造函数 list
list() # 创建一个空的列表，等同于 [] list(可迭代对象) # 用可迭代对象创建一个列表
示例
L = list() # L = [] L = list("ABC") # L = ['A', 'B', 'C'] L = list(range(5)) # L = [0, 1, 2, 3, 4]
2.访问列表中的值
2.1 索引
列表[整数表达式]
L = [1, 2, 3, 4, 5, 6] print(L[0]) # 1 print(L[-1]) # 6
与字符串的索引一样，列表索引从 0 开始，第二个索引是 1，依此类推。
列表是可变的容器(不同于字符串)
列表是可变的
字符串是不可变的
3.列表的数据操作(增、删、改、查)
3.1 添加数据（增）
-
方法
| 方法名(L代表列表) | 说明 |
|---|---|
| L.append(x) | 向列表的末尾追加单个数据 |
| L.insert(index, obj) | 将某个数据obj 插入到 index这个索引位置的数据之前 |
| L.extend(可迭代对象) | 等同于: L += 可迭代对象 |
-
示例
mylist1 = [1, 3, 4] # 目标是变成 [1, 2, 3, 4, 5] mylist1.append(5) # mylist1 = [1, 3, 4, 5] mylist1.insert(1, 2) # mylist1 = [1, 2, 3, 4, 5] mylist1.extend(range(6, 10)) # mylist1 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
3.2 修改数据 (改)
-
用索引赋值可以改变列表内的数据
列表[整数表达式] = 表达式
-
示例
mylist2 = [1, 1.99, 3] # 把1.99 改为2 mylist2[1] = 2 # mylist2 = [1, 2, 3]
3.3 删除数据 (删)
-
方法
方法 说明 L.remove(x) 从列表L中删除第一次出现在列表中的数据元素，如果x不存在则报错 L.clear() 清空列表 -
示例
L = [1, 2, 3, 4, 2, 2, 3, 4] L.remove(3) # L = [1, 2, 4, 2, 2, 3, 4] L.remove(3) # L = [1, 2, 4, 2, 2, 4] L.remove(3) # 报错了 L.clear() # L = []
-
-
del 语句删除指定位置的数据元素
-
语法
del 变量名 # 删除变量，同时解除变量绑定的对象 del 列表[整数表达式]
-
示例
L = ['张飞', '赵云', '鲁班7号', '孙悟空'] del L[2] # L = ['张飞', '赵云', '孙悟空'] del L # 删除 L 变量
-
-
列表的数据操作(增、删、改、查)
-
添加数据
-
方法
方法名(L代表列表) 说明 L.append(x) 向列表的末尾追加单个数据 L.insert(index, obj) 将某个数据obj 插入到 index这个索引位置的数据之前 L.extend(可迭代对象) 等同于: L += 可迭代对象 -
示例
mylist1 = [1, 3, 4] # 目标是变成 [1, 2, 3, 4, 5] mylist1.append(5) # mylist1 = [1, 3, 4, 5] mylist1.insert(1, 2) # mylist1 = [1, 2, 3, 4, 5] mylist1.extend(range(6, 10)) # mylist1 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
-
-
修改数据(改)
-
用索引赋值可以改变列表内的数据
列表[整数表达式] = 表达式
-
示例
mylist2 = [1, 1.99, 3] # 把1.99 改为2 mylist2[1] = 2 # mylist2 = [1, 2, 3]
-
-
删除数据(删)
-
方法
方法 说明 L.remove(x) 从列表L中删除第一次出现在列表中的数据元素，如果x不存在则报错 L.clear() 清空列表 -
示例
L = [1, 2, 3, 4, 2, 2, 3, 4] L.remove(3) # L = [1, 2, 4, 2, 2, 3, 4] L.remove(3) # L = [1, 2, 4, 2, 2, 4] L.remove(3) # 报错了 L.clear() # L = []
-
-
del 语句删除指定位置的数据元素
-
语法
del 变量名 # 删除变量，同时解除变量绑定的对象 del 列表[整数表达式]
-
示例
L = ['张飞', '赵云', '鲁班7号', '孙悟空'] del L[2] # L = ['张飞', '赵云', '孙悟空'] del L # 删除 L 变量
-
-
-
4.Python列表常用API
操作列表的函数
| 序号 | 函数 |
|---|---|
| 1 | len(list)列表元素个数 |
| 2 | max(list)返回列表元素最大值 |
| 3 | min(list)返回列表元素最小值 |
| 4 | list(seq)将元组转换为列表 |
列表的常用方法
| 运算 | 结果 |
|---|---|
s.index(x[, i[, j]]) | x 在 s 中首次出现项的索引号（索引号在 i 或其后且在 j 之前） |
s.count(x) | x 在 s 中出现的总次数 |
s.append(x) | 将 x 添加到序列的末尾 (等同于 s[len(s):len(s)] = [x]) |
s.clear() | 从 s 中移除所有项 (等同于 del s[:]) |
s.copy() | 创建 s 的浅拷贝 (等同于 s[:]) |
s.extend(t) 或 s += t | 用 t 的内容扩展 s (基本上等同于 s[len(s):len(s)] = t) |
s.insert(i, x) | 在由 i 给出的索引位置将 x 插入 s (等同于 s[i:i] = [x]) |
s.pop([i]) | 提取在 i 位置上的项，并将其从 s 中移除 |
s.remove(x) | 删除 s 中第一个 s[i] 等于 x 的项目。 |
s.reverse() | 就地将列表中的元素逆序。 |
s.sort( key=None, *reverse=False*) | 对列表内的数据进行排序, reverse=False 升序排序，否则是降序排序 |
示例:
s = [1, "二", 3] value = s.pop(1) # s= [1, 3]; value = '二' >>> s = [1, 2, 3, 5] >>> s.reverse() # 反转 >>> s [5, 3, 2, 1] >>> s = [1, 2, 3, 4, 2, 2, 3, 4] >>> s.index(3) # 返回第一次出现的位置的索引 2 >>> s.index(3, 4) 6 >>> s.index(100) # 触发异常，要用try 语句处理 Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: 100 is not in list >>> s.count(3) # 在列表 s 中 找出所有值为3 的元素的个数，并返回 2 >>> s.count(2) 3 >>> L1 = [2, 4, 6, 8, 9, 1] >>> L1.reverse() >>> L1 [1, 9, 8, 6, 4, 2] >>> s.sort() # 排序，默认是升序排序 >>> s [1, 2, 2, 2, 3, 3, 4, 4] >>> s.sort(reverse=True) >>> s [4, 4, 3, 3, 2, 2, 2, 1]
五.元组(tuple)
-
元组是不可改变的列表
-
同列表list 一样，元组可以存放任意类型的数据
-
但是，一旦创建将不可修改
-
元组使用小括号 ( )，列表使用方括号 [ ]
1.元组的创建
创建元组的字面值
用小括号() 括起来，单个元素括起来后加逗号来区分单个元素还是元组
t = () # 空元组 t = (100,) # 含有一个数据元素的元组 t = 100, # 含有一个数据元素的元组，元组中只包含一个元素时，需要在元素后面添加逗号 ，否则括号会被当作运算符使用 t = (1, 2, 3) # 含有三个数据元素的元组 t = ( 'hqyj', 2004) # 存放不同类型的元组 t = 1, 2, 3 # 含有三个数据元素的元组
type(x) 函数用来返回数据x的类型
创建元组的函数 tuple
t = tuple() # t = () t = tuple(range(5)) # t = (0, 1, 2, 3, 4)
2.元组的数据操作（删，查，运算）
2.1 删除元组
元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组
tup = ('openAI', 'hqyj', 100, 200)
print (tup)
del tup
print (tup)#name 'tup' is not defined
2.2 查看元组
元组与字符串类似，下标索引从 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)
2.3 元组的运算
元组中的元素值是不允许修改的，但我们可以对元组进行连接组合
tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
# 创建一个新的元组
tup3 = tup1 + tup2
print (tup3)
>>> t = (1, 2, 3) + (4, 5, 6)
>>> t += (7, 8, 9) # 等同于 t = t + (7, 8, 9)
>>> t = t * 2
>>> t *= 2
>>> 5 in t
True
3.元组不可变
所谓元组的不可变指的是元组所指向的内存中的内容不可变。
tup = (1, 2, 3, 4, 5, 6, 7) tup[1] = 100 print(tup)#报错'tuple' object does not support item assignment
4.元组常用API
Python元组包含了以下内置函数
| 序号 | 方法 | 描述 |
|---|---|---|
| 1 | len(tuple) | 返回元组中元素个数。 |
| 2 | max(tuple) | 返回元组中元素最大值。 |
| 3 | min(tuple) | 返回元组中元素最小值。 |
| 4 | tuple(list) | 将列表转换为元组。 |
元组常用的方法
| 运算 | 结果 |
|---|---|
| s.index(x[, i[, j]]) | x 在 s 中首次出现项的索引号（索引号在 i 或其后且在 j 之前） |
| s.count(x) | x 在 s 中出现的总次数 |
Python字典(dict )
-
字典是一种可变容器模型，且可存储任意类型对象。
-
字典的数据都是以键(key)-值(value)对的形式进行映射存储.
-
字典的每个键值对( key:value )用冒号分割，每个对之间用逗号分割，整个字典包括在花括号 {} 中
-
d = {key1 : value1, key2 : value2, key3 : value3 }
-
字典的数据是无序的
-
字典的键不能重复，且只能用不可变类型作为字典的键
-
字典中的数据只能用"键"key 进行索引，不能用整数进行索引
1.字典的创建
-
创建字典的字面值:
字典的表示方式以 {} 括起来， 以英文的冒号 (:) 分隔键值对，各键值对之间用逗号(,)分隔
d = {} # 创建空字典
d = {'name': "weimingze", "age": 35}
d = {'a': [1, 2, 3]}
d = {'b': {"bb": 222}}
d = {1:'壹', 2:'贰', 5:'伍'}
d = {(1, 2, 3):'壹贰伍'}
以下写法会存在问题
-
键必须是唯一的，但值则不必。
-
值可以取任何数据类型，但键必须是不可变的，如字符串，数字。
d = {'a': 1, 'b': 2, 'a': 3} # 字典的键不能重复 d = {'a': 3, 'b': 2}
d = {[1, 2, 3]: 'a'} # 不能用可变类型作为字典的键 # 报错
-
字典的创建函数 dict（）
d = dict() # d = {}
d = dict([("name", "小王"), ("age", 35)]) # {'name': '小王', 'age': 35}
d = dict(a=1, b=2, c=3) # {'a':1, 'b':2, 'c':3}
d = dict([1, 2, 3, 4]) # 错
2.字典的数据操作（增、删、改、查）
2.1 增加和修改字典
-
添加和修改字典的元素
-
语法
字典[键key] = 表达式
键不存在, 会创建键并绑定键对应的值
键存在, 会改变键对应的值
-
示例:
d = {} d['name'] = 'tarena' # 添加键值对 d = {'name': 'tarena'} d['age'] = 18 # d = {'name': 'tarena', 'age': 18} d['age'] = 19 # 改变 'age' 键对应的值 d = {'name': 'tarena', 'age': 19}
-
2.2 访问字典里的值
-
字典的键索引
-
语法
字典[键key]
用键索引可以查看字典中的数据
-
示例:
d = {'one': 1, 'two': 2} print(d['two'])
-
如果用字典里没有的键访问数据，会输出错误
mydic = {'Name': 'hqyj', 'Age': 7, 'Class': 'First'}
print (mydic['Alice'])
2.3 删除字典元素
能删单一的元素也能清空字典，清空只需一项操作
显式删除一个字典用del命令
-
语法
del 字典[键]
-
示例
mydic = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
del mydic['Name'] # 删除键 'Name'
mydic.clear() # 清空字典
print (mydic['Age'])
print (mydic['School'])
del mydic # 删除字典
3.字典键的特性
字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。
1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住
mydic = {'Name': 'jack', 'Age': 27, 'Name': 'karen'}
print (mydic['Name'])
2）键必须不可变，所以可以用数字，字符串或元组充当，而用列表等就不行
mydic1 = {97:"a",98:"b"}
mydic2 = {"name":"karen","age":27}
mydic3 = {['Name']: 'karen', 'Age': 27}
print(mydic3[['Name']])#报错unhashable type: 'list'
注: python 中有四种可变类型
-
列表 list
-
字典dict
-
集合 set
-
字节数组 bytearray
字典是可迭代对象, 字典只能对所有的键进行迭代访问
d = {'name': 'tarena', 'age': 19}
for k in d:
print(k)
name
age
for k in d:
print("key=", k, 'value=', d[k])
key= name value= tarena
key= age value= 19
4.字典常用API
操作字典的函数：
| 序号 | 函数 | 描述 |
|---|---|---|
| 1 | len(dict) | 计算字典元素个数，即键的总数。 |
| 2 | str(dict) | 输出字典，可以打印的字符串表示。 |
| 3 | type(variable) | 返回输入的变量类型，如果变量是字典就返回字典类型。 |
字典的方法：
| 序号 | 函数及描述 |
|---|---|
| 1 | dict.clear()删除字典内所有元素 |
| 2 | dict.copy()返回一个字典的浅复制 |
| 3 | dict.fromkeys(seq)创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值 |
| 4 | dict.get(key, default=None)返回指定键的值，如果键不在字典中返回 default 设置的默认值 |
| 5 | key in dict如果键在字典dict里返回true，否则返回false |
| 6 | dict.items()以列表返回一个视图对象 |
| 7 | dict.keys()返回一个视图对象 |
| 8 | dict.setdefault(key, default=None)和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default |
| 9 | dict.update(dict2)把字典dict2的键/值对更新到dict里 |
| 10 | dict.values()返回一个视图对象 |
| 11 | pop(key,default)删除字典 key（键）所对应的值，返回被删除的值。 |
| 12 | popitem()返回并删除字典中的最后一对键和值。 |
-
示例
>>> d = {'name': 'tarena', 'age': 19} >>> >>> d['age'] 19 >>> d['address'] Traceback (most recent call last): File "<stdin>", line 1, in <module> KeyError: 'address' >>> d.get('address', '未填写住址') '未填写住址' >>> d.get('age', 0) 19 >>> n = d.pop('name') >>> d { 'age': 19} >>> n 'tarena'
5.列表、元组、字典小结
-
列表和元组是有序的，字典的存储是无序的
-
列表、字典是可变的,元组是不可变的
-
字典的键索引速度快，列表的索引速度也快
d = {'a':1, 'b':2, .........} print(d['c']) # 速度快 L = [7, 5, 1, ........] print(L[10009]) # 速度快 -
列表和元组是顺序存储的，字典是散列存储的
-
字典的 in / not in 运算符快于列表的 in / not in 运算符
L = ['孙悟空', '赵云', '吕布', ...] if '王昭君' in L: # 速度慢 pass D = {'孙悟空':'花果山', '赵云':'长山', '吕布':'石家庄', .....} if '王昭君' in D: # 速度快 pass
949
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
