这篇博客详细介绍了Python的基础数据类型，包括数值（整数、浮点数、复数、布尔值）、数学函数、随机数生成、字符串（运算符、格式化、方法）、列表（创建、访问、操作符、方法）、元组、集合和字典。还涵盖了各数据类型的操作和转换，以及常见的数学计算和数据结构的使用技巧。
数值
数值分为：整数(int)、浮点数(float)、复数(complex)、布尔值(bool)
数值类型之间的转换：
-
int(x)：把其他类型转换成整数
-
float(x)：把其他类型转换成浮点数
-
bool(x)：把其他类型转换成布尔型
-
complex(x)：把x转换成复数。实数为x，虚数为0
-
complex(x,y)：把x,y转换成复数。实数为x，虚数为y
常用的数学函数：（需要导入数学类库。import math）
-
abs(x)：绝对值
-
ceil(x)：向上取整
-
floor(x)：向下取整
-
round(x)：四舍五入
-
exp(x)：返回e的x次方
-
log(x)：返回底数为e的对数
-
log10(x)：返回底数为10的对数
-
max(x1,x2,….)：最大值
-
min(x1,x2,…)：最小值
-
pow(x,y)：幂。相当于x**y
-
sqrt(x)：开方
数值之间的比较
>>= <<= == !=（运算符）
随机数。需要导入import random
-
random.choice(seq)：从序列中随机选择一个元素
-
random.random()：随机生成一个0~1之间的实数
-
random.shuffle()：随机打乱序列中的元素。俗称洗牌
-
random.uniform(x,y)：随机生成x~y之间的实数
-
random.randint(x,y)：随机生成x~y之间的int类型
-
random.sample(sequence,length)：随机在序列中截取一段长度
import random
value1 = random.random() # 0~1
print(value1)
list = [1,2,3,4,5,6,7,8,9]
random.shuffle(list) # 洗牌
print(list) # [5, 1, 9, 7, 4, 8, 2, 6, 3]
三角函数
-
sin(x)：正弦
-
cos(x)：余弦
-
tan(x)：正切
-
atan(x)：反正切
-
asin(x)：反正弦
-
acos(x)：反余弦
-
degrees(x)：弧度转角度
-
radians(x)：角度转弧度
注意sin、cos、tan的参数是弧度的单位。
思考：扔骰子，随机生成123456中的一个数。
import random
random.random() # 0.00000001~0.9999999
random.random() * 6# 0.00000001~5.9999999
result = math.ceil(random.random() * 6) # 1~6
print(result)
result = random.randint(1,6) # 1~6
print(result)
思考：随机生成0 20 40 60 80 100 …… 980之间的一个数
import random
random.random() # 0.00000001~0.9999999
random.random() * 50# 0.0000001~49.99999999
math.floor(random.random() * 50) # 0 1 2 3 4 …… 49
result = math.floor(random.random() * 50) * 20# 0 20 40 60 80 …… 980
print(result)
数学常量
-
pi：圆周率
-
e：自然对数
字符串
Python中，可以通过双引号或单引号表示字符串。
Python中优先考虑使用单引号
字符串常用的运算符
-
+：字符串连接
-
*：字符串重复
-
[]：通过索引访问字符串中的字符
str = 'helloworld'
print(str) # helloworld
print(str[4]) # o
print(str[0]) # h
print(str[-1]) # d 倒数第一个
print(str[1:3]) # el 从第1个开始 到第3个结束 包含第1个 不包含第3个
print(str[1:]) # elloworld 从第1个开始到最后 包含第1个
print(str[:3]) # hel 从头开始到第3个结束 不包含第3个
-
in：判断字符串中是否有指定的字符
-
not in：判断字符串中是否没有指定的字符
-
%：格式化字符串
-
转义字符\
字符串中使用特殊字符
-
\\：输出反斜杠
-
\’：输出单引号
-
\"：刷出双引号
-
\n：换行
-
\r：回车
-
\t：制表符
-
\b：退格
格式化字符串。从C中继承过来的
-
%c：输出ASCII码
-
%f：输出浮点数
-
%d：输出整数
-
%s：输出字符串
-
%u：无符号整数
-
%o：八进制
-
%x：十六进制
辅助指令
-
m.nf%：输出长度为m，保留n位有效小数
-
+号：在正数前面加上+号
-
-号：左对齐
-
0：在前面补0
-
%：%%输出一个%
pi = 3.1415926535847
print("--%f--" % pi) # --3.141593--
print("--%.2f--" % pi) # --3.14-- 保留2位小数
print("--%6.2f--" % pi) # -- 3.14-- 输出长度为6位
print("--%-6.2f--" % pi) # --3.14 -- 左对齐
print("--%+6.2f--" % pi) # --3.14 -- 前面显示+号
print("--%06.2f--" % pi) # --003.14-- 前面补0
print("--%2f%%--" % pi) # --3.141593%--
name1 = "zhangsan"
age1 = 23
height1 = 178.2
#print("name:", name1, ",age:", age1, ",height:", height1)
print("name: %10s, age: %2d, height: %6.1f" % (name1, age1, height1))
name2 = "lisi"
age2 = 9
height2 = 93
print("name: %10s, age: %2d, height: %6.1f" % (name2, age2, height2))
字符串的常用方法/函数
-
startswith(prefix)：字符串是否以prefix开头
-
endswith(suffix)：字符串是否以suffix结尾
-
find(str)：在字符串中查找子串
-
len(str)：求字符串的长度
-
lower(str)：字符串转成全部小写
-
upper(str)：字符串转成全部大写
列表
-
列表使用中括号把多个数值包括起来
-
列表的类型为list
list = ['baidu', 'alibaba', 'tencent']
print(type(list)) # <class 'list'>
列表中每个元素的类型可以不一样
list = [23, 3.14, False, *'hello'*, 3+2j, [*'zhangsan'*,*'lisi'*,*'wangwu'*]]
print(list)
列表的长度可以通过len()函数获取
list = [*'baidu'*, *'alibaba'*, *'tencent'*] |
print(len(list)) # 4
访问列表中的元素，下标从0开始。注意：下标可以为负数，表示倒数第几个
list = [1,2,3,5,8,13,21,34]
print(list[3]) # 5
print(list[0]) # 1
print(list[-1]) # 34
print(list[-3]) # 13
print(list[1:3]) # [2,3] 从第1个开始 到第3个结束 包含第1个 不包含第3个
print(list[1:-1]) # [2, 3, 5, 8, 13, 21] 从第1个开始 到倒数第1个结束 包含第1个 不包含倒数第1个
print(list[1:]) # [2, 3, 5, 8, 13, 21, 34] 从第1个开始到最后 包含第1个
print(list[:3]) # [1, 2, 3] 从头开始到第3个结束 不包含第3个
print(list[:]) # [1, 2, 3, 5, 8, 13, 21, 34] 从头开始到最后
print(list[1:6:2]) # [2, 5, 13] 从第1个开始到第6个结束 包含第1个 不包含第6个 步长为2
print(list[::2]) # [1, 3, 8, 21] 从头开始到最后 步长为2
print(list[-1:-5:-1]) # [34, 21, 13, 8] 从倒数第1个开始到倒数第5个结束 包含倒数第1个 不包含倒数第5个 步长为-1
print(list[7:0:-1]) # [34, 21, 13, 8, 5, 3, 2]
# 步长为-1的情况下 怎样才能出现1
print(list[::-1]) # [34, 21, 13, 8, 5, 3, 2, 1] 从最后到最前
PS. 步长不能为0
1.append()
往列表中增加元素的方法
list = [1,2,3,5,8,13,21,34]
print(list) # [1, 2, 3, 5, 8, 13, 21, 34]
list.append(55)
print(list) # [1, 2, 3, 5, 8, 13, 21, 34, 55]
如果要一次性添加多个元素
list = [1,2,3,5,8,13,21,34]
print(list) # [1, 2, 3, 5, 8, 13, 21, 34]
list.append(55,89)
会报错
原因是append()方法只能传递一个参数。
尝试改成
list.append([55,89]) # 合成一个元素
print(list) # [1, 2, 3, 5, 8, 13, 21, 34, [55, 89]]
print(len(list)) # 9
会发现程序会把55和89合并到一个新列表中，作为一个元素添加到原来的列表中
不符合我们的要求。
2.extends()
extends()可以满足我们上面的要求，一次添加多个元素
list = [1,2,3,5,8,13,21,34]
print(list) # [1, 2, 3, 5, 8, 13, 21, 34]
list.extend([55,89])
print(list) # [1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
print(len(list)) # 10
3.insert()
Insert()可以在列表的前面或中间插入
insert()需要2个参数。
-
参数1 索引。在哪里插入
-
参数2 值。插入的元素
list = [1,2,3,5,8,13,21,34]
print(list) # [1, 2, 3, 5, 8, 13, 21, 34]
list.insert(0, 'new')
print(list) # ['new', 1, 2, 3, 5, 8, 13, 21, 34]
list = [1,2,3,5,8,13,21,34]
print(list) # [1, 2, 3, 5, 8, 13, 21, 34]
list.insert(2, 'new')
print(list) # [1, 2, 'new', 3, 5, 8, 13, 21, 34]
list = [1,2,3,5,8,13,21,34]
print(list) # [1, 2, 3, 5, 8, 13, 21, 34]
list.insert(8,'new')
print(list) # [1, 2, 3, 5, 8, 13, 21, 34, 'new']
从列表中删除元素的方法：
1 remove() 根据值来删除指定的元素
list = [1,2,3,5,8,13,21,34]
print(list) # [1, 2, 3, 5, 8, 13, 21, 34]
list.remove(5)
print(list) # [1, 2, 3, 8, 13, 21, 34]
2 pop() 根据索引来删除元素（如果不指定参数，则删除列表的最后一个元素）
Pop()函数的返回值是被删除的元素
list = [1,2,3,5,8,13,21,34]
print(list) # [1, 2, 3, 5, 8, 13, 21, 34]
result = list.pop(5)
print(list) # [1, 2, 3, 5, 8, 21, 34]
print(result) # 13
result = list.pop()
print(list) # [1, 2, 3, 5, 8, 21]
print(result) # 34
3 del
根据索引来删除元素。del是关键字，没有返回值
list = [1,2,3,5,8,13,21,34]
print(list) # [1, 2, 3, 5, 8, 13, 21, 34]
del list[5]
print(list) # [1, 2, 3, 5, 8, 21, 34]
4 指定索引的值为空
list = [1,2,3,5,8,13,21,34]
print(list) # [1, 2, 3, 5, 8, 13, 21, 34]
list[5:6] = []
print(list) # [1, 2, 3, 5, 8, 21, 34]
思考：
创建一个列表，写入100个0
list = [0,0,0,0,0,0,0,0,0,0,0,……]
创建一个列表，写入数值1~100
list = [1,2,3,4,5,6,7,8,9,10,11,12,13,….]
# 创建一个列表，写入100个0
list = []
# 屌丝的代码
for i in range(100):
list.append(0)
print(list)
print(len(list))
# 大神的代码(慎用)
list = [0for i in range(100)]
print(list)
print(len(list))
# 创建一个列表，写入数值1~100
list = []
# 屌丝的代码
for i in range(1,101):
list.append(i)
print(list)
# 大神的代码(慎用)
list = [i for i in range(1,101)]
print(list)
可以把一个列表嵌套在另一个列表中
list = [13, 2.5, *'hi'*, [*'baidu'*, *'alibaba'*, *'tencent'*]]
print(list[3][0]) # baidu
如果一个列表中的所有元素都是其他列表，称为二维列表
初始化二维列表
# 屌丝的代码
list = []
for j in range(3):
inner_list = []
for i in range(5):
inner_list.append(0)
list.append(inner_list)
print(list) # [[0, 0, 0, 0, 0],
# [0, 0, 0, 0, 0],
# [0, 0, 0, 0, 0]]
# 大神的代码(慎用)
list = [[0for i in range(5)] for j in range(3)]
print(list) # [[0, 0, 0, 0, 0],
# [0, 0, 0, 0, 0],
# [0, 0, 0, 0, 0]]
排序
前提是列表中的数据类型是一样的。
如果列表中的数值顺序是乱的，可以通过sort()进行排序
list = [13, 3, 21, 8, 5, 1, 34, 2]
print(list) # [13, 3, 21, 8, 5, 1, 34, 2]
# 正向排序(从小到大)
list.sort()
print(list) # [1, 2, 3, 5, 8, 13, 21, 34]
# 反向排序(从大到小)
list.sort(reverse = True)
print(list) # [34, 21, 13, 8, 5, 3, 2, 1]
反向操作。
把列表的序列颠倒
使用reverse()方法
list = [13, 3, 21, 8, 5, 1, 34, 2]
list.reverse()
print(list) # [2, 34, 1, 5, 8, 21, 3, 13]
当然也可以使用这个方法
list = [13, 3, 21, 8, 5, 1, 34, 2]
list = list[::-1]
print(list) # [2, 34, 1, 5, 8, 21, 3, 13]
列表相关的操作符：
-
+：列表拼接
-
*：列表复制
-
in：判断元素是否在列表中
-
not in：判断元素是否不在列表中
clist1 = [1,2,3]
list2 = [5,6,7]
list3 = list1 + list2
print(list3) # [1, 2, 3, 5, 6, 7]
list1 = ['a','b','c','d']
list2 = list1 * 4
print(list2) # ['a', 'b', 'c', 'd', 'a', 'b', 'c', 'd', 'a', 'b', 'c', 'd', 'a', 'b', 'c', 'd']
list = [1,2,3,4,5,6,7]
print(3in list) # True
print(3notin list) # False
print('3'in list) # False
print('3'notin list) # True
清空列表
list.empty()
思考下面的问题：
list1 = [1,2,3]
list2 = list1
print(list1) # [1, 2, 3]
print(list2) # [1, 2, 3]
list1[2] = 4
print(list1) # [1, 2, 4]
print(list2) # [1, 2, 4]
Why?
Python 序列（字符串、列表、元组、字典、集合）
可以选择如下的方法：
import copy
list1 = [1,2,3]
# 方法一：list.copy()
list2 = list1.copy()
# 方法二：copy.copy()
#list2 = copy.copy(list1)
# 方法三：切片
#list2 = list1[:]
print(list1) # [1, 2, 3]
print(list2) # [1, 2, 3]
print(id(list1))
print(id(list2))
list1[2] = 4
print(list1) # [1, 2, 4]
print(list2) # [1, 2, 3]
原理如下，注意python中赋值语句左边的变量都认为是在栈上的
思考下面的问题：
list = []
list1 = [1,2,3]
list2 = [4,5,6]
list3 = [7,8,9]
list.extend([list1,list2,list3])
print(list)
list_tmp = copy.copy(list)
print(list_tmp)
print(id(list_tmp))
list1[2] = 4
print(list) # [[1, 2, 4], [4, 5, 6], [7, 8, 9]]
print(list_tmp) # [[1, 2, 4], [4, 5, 6], [7, 8, 9]]
copy只是把list复制了一份，如果复制的list中嵌套了其他list，其他list的地址是不会改变的，这个俗称浅拷贝。如果想要把其他list也改变，就需要copy.deepcopy()，这个俗称深拷贝。
list = []
list1 = [1,2,3]
list2 = [4,5,6]
list3 = [7,8,9]
list.extend([list1,list2,list3])
print(list)
list_tmp = copy.deepcopy(list)
print(list_tmp)
print(id(list_tmp))
list1[2] = 4
print(list) # [[1, 2, 4], [4, 5, 6], [7, 8, 9]]
print(list_tmp) # [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
原理如下：
元组
Python中使用小括号表示元组，元组是tuple
tuple = (1,2,3,5,8,13,21)
print(type(tuple)) # <class 'tuple'>
可以通过len()函数求tuple的长度
print(len(tuple)) # 7
元组中各个元素的类型可以不同
tuple = (14, 3.14, *'str'*, True, [1,2,3], (*'ha'*, *'he'*, *'hi'*))
print(type(tuple)) # <class 'tuple'>
如果元组的长度为1，需要在后面加上逗号，以便与整数区分
tuple = (3,5,8)
print(type(tuple)) # <class 'tuple'>
tuple = (3,5)
print(type(tuple)) # <class 'tuple'>
tuple = (3,)
print(type(tuple)) # <class 'tuple'>
tuple = (3)
print(type(tuple))
元组的小括号可以省略（虽然不建议）
tuple = 1,2,3
print(type(tuple)) # <class 'tuple'>
PS. python中一个函数可以返回多个值，其实返回的就是个元组（没有小括号）
def fun():
return 3,5
result1,result2 = fun()
print(type(result1)) # <class 'int'>
print(type(result2)) # <class 'int'>
result = fun()
print(type(result)) # <class 'tuple'>
元组访问元素的方式基本上和列表时一样的
tuple = (1,2,3,5,8,13,21)
print(tuple[-3]) # 8
print(tuple[3:-1]) # (5, 8, 13)
print(tuple[::2]) # (1, 3, 8, 21)
元组是不能改变的，因此无法进行增加、删除、修改的功能
tuple = (1,2,3,5,8,13,21)
tuple.append(34)
tuple = (1,2,3,5,8,13,21)
tuple.remove(5)
tuple = (1,2,3,5,8,13,21)
tuple[2] = 8
元组操作符：
-
+：元组拼接
-
*：元组复制
-
in：判断元素是否在元组中
-
not in：判断元素是否不在元组中
tuple1 = (1,2,3)
tuple2 = ('a','b','c')
tuple3 = tuple1 + tuple2
print(tuple3) # (1, 2, 3, 'a', 'b', 'c')
tuple1 = (1,2,3) * 3
print(tuple1) # (1, 2, 3, 1, 2, 3, 1, 2, 3)
tuple1 = (1,2,3)
print(2in tuple1) # True
print('2'in tuple1) # False
print(2notin tuple1) # False
print('2'notin tuple1) # True
元组与列表相互转换
# 元组转列表
tuple1 = (1,2,3)
list1 = list(tuple1)
print(list1) # [1, 2, 3]
# 列表转元组
list2 = [4,5,6]
tuple2 = tuple(list2)
print(tuple2) # (4, 5, 6)
集合
集合的特点：无序，不重复
set1 = {14, 3.14, True, 'str'}
print(type(set1)) # <class 'set'>
可以增删；不能改查
集合不能通过下标访问元素
set1 = {14, 3.14, True, 'str'}
print(set1[1])
操作符：
-
in：判断元素是否在集合中
-
not in：判断元素是否不在集合中
添加元素
使用add()方法添加元素
set1 = {1,2,3}
set1.add(4)
print(set1) # {1, 2, 3, 4}
使用update()方法添加多个元素
set1 = {1,2,3}
set1.update({4,5})
print(set1) # {1, 2, 3, 4, 5}
使用remove()方法移除元素
set1 = {1,2,3}
set1.remove(2)
print(set1) # {1, 3}
如果使用remove()移除的元素不存在，则报错
set1 = {1,2,3}
set1.remove(4)
此时，可以考虑使用discard()函数去删除元素。即使要删除的元素不存在，也不会报错
set1 = {1,2,3}
set1.discard(2) # 能够删除元素
set1.discard(4) # 不能删除元素 但不会报错
print(set1) # {1, 3}
其他序列转集合，通过set()调用即可
list1 = [1,2,3,4,5]
set1 = set(list1)
print(set1) # {1, 2, 3, 4, 5}
tuple1 = ('a','b','c','d')
set1 = set(tuple1)
print(set1) # {'c', 'b', 'd', 'a'}
pop()随机删除一个元素
clear()清空序列
集合之间的运算：
-
set1-set2：在set1中去掉set2中有的元素
-
set1&set2：交集
-
set1|set2：并集
-
set1^set2：异或集
字典
PS. 如果是空的大括号算是字典（不算集合）
dict1 = {}
print(type(dict1)) # <class 'dict'>
键值对。通过键查找对应的值。格式：
dict = {key1: value1, key2: value2, …. keyn: valuen}
比如：
dict1 = {*"name"*:*"yangbing"*, *"age"*:80, *"height"*:152.3, *"married"*:True}
print(dict1)
字典的key可以是字符串（常用）、整数、元组
通过下标访问字典的元素，下标的key为字典的key
dict1 = {*"name"*:*"yangbing"*, *"age"*:80, *"height"*:152.3, *"married"*:True}
print(dict1[*'name'*]) \# *yangbing*
如果key不存在，报错
dict1 = {*"name"*:*"yangbing"*, *"age"*:80, *"height"*:152.3, *"married"*:True}
print(dict1[*'weight'*]) \# 报错
get()根据键获取值
dict1 = {*"name"*:*"yangbing"*, *"age"*:80, *"height"*:152.3, *"married"*:True}
age = dict1.get(*'age'*)
print(age)
通过下标（字典的key）修改字典中的元素
dict1 = {"name":"yangbing", "age":80, "height":152.3, "married":True}
dict1['height'] = 155.5
print(dict1) # {…… 'height': 155.5 ……}
如果修改的使用key不存在，就会增加对应的元素
dict1 = {"name":"yangbing", "age":80, "height":152.3, "married":True}
dict1['weight'] = 255.5
print(dict1) # {…………, 'weight': 255.5}
如果要删除字典中的元素，通过pop()，传递key作为参数
dict1 = {"name":"yangbing", "age":80, "height":152.3, "married":True}
dict1.pop('married')
print(dict1) # …… 没有married了
del也可以
dict1 = {"name":"yangbing", "age":80, "height":152.3, "married":True}
del dict1['married']
print(dict1) # …… 没有married了
通过in关键字，判断字典中是否有对应的key。
dict1 = {"name":"yangbing", "age":80, "height":152.3, "married":True}
print('name'in dict1) # True
print('name'notin dict1) # False
print('weight'in dict1) # False
print('weight'notin dict1) # True
遍历字典。
- 方法一：通过字典的items()，返回两个值：key和value
dict1 = {"name":"yangbing", "age":80, "height":152.3, "married":True}
for key, value in dict1.items():
print(key, value)
- 方法二：keys()返回所有的键, 先获取所有的键，再根据键获取对应的值
dict1 = {"name":"yangbing", "age":80, "height":152.3, "married":True}
keys = dict1.keys()
for key in keys:
value = dict1.get(key)
print(key, value)
clear()清除字典中所有的元素。略
copy()拷贝一份。原理与list中的copy()类同
字典可以嵌套
dict1 = {
'湖南': {
'长沙':{
'岳麓','雨花','芙蓉','天心'
},
'郴州':'xxx'
},
'广东': {
'广州':{
'白云','越秀','天河'
},
'珠海':{},
'深圳':{}
}
}
print(dict1)
这个跟json字符串差不多
习题
1 给出三维坐标上的两个点p1、p2。其中p1和p2为列表类型，长度为3，比如：
p1 = [3,5,2] p2 = [-1,0, -3]
要求计算它们之间的曼哈顿距离（L1距离）、欧氏距离（L2距离）
2 从终端输入多个学生的个人信息，并保存到一个列表中，列表中每个元素是一个字典。
list1 = [{‘name’:’zhangsan’, ‘age’:23, ‘height’:178.2}, {‘name’:’lisi’,
‘age’:42, ….}, {….}]
比如：
输入姓名（字符串）：zhangsan
输入年龄（整数）：23
输入身高（浮点数）：178.2
继续(1继续 0退出)？1
输入姓名（字符串）：lisi
输入年龄（整数）：42
输入身高（浮点数）：162.7
继续(1继续 0退出)？1
输入姓名（字符串）：wangwu
输入年龄（整数）：55
输入身高（浮点数）：155.5
继续(1继续 0退出)？0
然后，打印出整个列表
本章项目源码
URL：https://gitee.com/yuanbaonet/master_python/tree/baoai_python_v6/
对应版本：baoai_python_v6
对应文件：sample/python/p6.py
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
