python基础03（不同类型变量的操作）

多多炒冷饭记住😔可怜鱼的记忆的我……来回顾下我们01的变量类型：数字类型、布尔类型、字符串、列表 (List) 、元组 (Tuple)、字典 (Dictionary)、集合 (Set)

数据类型	可变性	语法	特点
数字	❌不可变	1, 3.14	整数、浮点数等
布尔	❌ 不可变	True, False	逻辑值，只有两个值
字符串	❌不可变	"hello"	字符序列
列表	✅ 可变	[1, 2, 3]	有序，可修改
元组	❌ 不可变	(1, 2, 3)	有序，不可修改
字典	✅ 可变	{"a": 1}	键值对
集合	✅ 可变	{1, 2, 3}	无序，去重

---

数字

【算术运算】

加（+）、减（-）、乘（*）、除（/）、整除（//）、取模（%）、指数（**）

【类型转换】

int(值) 、float（值）

#特殊字符

float('inf')  # 正无穷大

float('-inf')  # 负无穷大

float('nan')  # 非数字

【内置数学函数】

求最大值：max(某个数字列表)、

求最小值：min(某个数字列表)、

求和：sum(某个数字列表)、

求个数：len(某个数字列表)

绝对值：abs(-1)  # 结果为1

四舍五入：round(3.14159,2)  # 结果为3.14

幂运算：pow(2,3)  #结果为8，等价于2**3        

【课学计算相关】

import math

math.pi # 派

math.hypot(x,y) # 勾股定理

math.log10(x) # 以10为底x的对数

math.isinf(float('inf'))  #结果为 True

math.isnan(float('nan'))  #结果为 True

math.sqrt(x) # x的平方根，比如x=16的结果是4.0

math.floor(x) # 向下取整，比如x=0.1结果是0

math.ceil(x) # 向上取整，比如x=0.1结果是1

math.factorial(x) # x的阶乘x!=x*(x-1)*(x-2)*……*3*2*1,注意0和1的阶乘都是1

math.gcd(x,y) # 最大公约数x=12,y=18结果是6

【随机数相关】

import random

random.random()  # [0,1) 之间的随机浮点数

random.randint(1,10)  #[1,10] 之间的随机整数

random.uniform(1,10)  # [1,10] 之间的随机浮点数

random.choice([1,2,3])  # 从序列中随机选择一个

【小数精度控制】

from decimal import Decimal

Decimal('0.1')+Decimal('0.2')==Decimal('0.3')

字符串

# 注意字符串是不可变类型，没有重新赋值，仅操作是生成新的字符串，不会概变原来】的

【格式化】

x="1"

y=f"xxx{x}xxxx"  # y值为xxx1xxxx

y="xxx{}xxxx{}".format(x,x)  # y值为xxx1xxxx1

# 字符串填充

x.ljust(10, "x")  # "1xxxxxxxxx" - 左对齐

x.rjust(10, "x")  # "xxxxxxxxx1" - 右对齐

x.center(10, "x") # "xxxx1xxxxx" - 居中,先整除获取左边的填充数量

# 去除空格

x=" 1 2 3 abc "

x.strip()  # 结果为"1 2 3 abc"

x.lstrip()  # 结果为"1 2 3 abc "

x.rstrip()  # 结果为"1 2 3 abc "

【字符串校验】

x=" 1 2 3 abc "

x.isdigit()   #结果为 False

x.isalpha()  #结果为 False

x.isalnum()  #结果为 False

x=" 123abc "

x.isalnum()  #结果为 True

【字符串连接】

message="a"+"b" # print(message)为ab

【字符串重复】

message=".-"*3  # print(message)为.-.-.-

【获取字符串长度】

message="abc123"

print(len(message)) # 结果为6

【替换】

message="abc123a"

print(message.replace("a","0")) # 结果为0bc1230

【分割字符串】

message="a b c d e f 1 2 3"

message.split(" ")  # 结果为[a,b,c,d,e,f,1,2,3]  也可以直接message.split() 

【字符串索引切片】

# 完整语法：变量[开始:结束:步长] 

message="abcdef123"

print(message[0]) # 结果为a

print(message[-1]) # 结果为3

print(message[0:3]) # 结果为abc

print(message[:]) # 结果为abcdef123

print(message[::2]) # 结果为ace13

print(message[::-1]) # 结果为321fedcba（反转)

print(message[-2:-5:-2]) # 结果为2f

print(message[6:]) # 结果为123

print(message[:6]) # 结果为abcdef

# 转置

message=[[1,2,3],[4,5,6],[7,8,9]]

new_message=[list(row) for row in zip(*message)] 

# new_message 结果为 [[1,4,7],[2,5,8],[3,6,9]]

# *message 解包 变成了[1,2,3],[4,5,6],[7,8,9] 3个单独的列表

# zip(*message)] 等于把解包之后的又组合，zip拉链一样的组合

# 枚举 enumerate 音标：/ɪˈnjuːməreɪt/ 谐音：以-纽-么-瑞特

for i,m in enumerate(message,start=n):

    pass

# i是索引编号从start开始，start可以省略不写

【大小写转换】

message="abcdeF123"

message.upper() # 结果转为ABCDEF123

message.lower() # 结果转为abcdef123

【类型转换】

str(1)  

a = "abc"

# 定义a为字符串

l = ["1", 2, a]

# 转所有元素为字符串

l_str = [str(i) for i in l]

s = "#".join(l_str) print(s)  # 输出：1#2#a#b#c,join用的迭代对象钟的所有元素必须是字符串

【查找元素】

# 只有字符串有find，index列表、元组、字符串都支持

message="abcdeF123"

message.find("a") # 结果0

message.find("A") # 结果-1

message.index("a") # 结果0

message.index("A") # 结果报错ValueError

元组

# 支持解包

c = (1,"2",3)

x,y,z=c # x=1,y="2",c=3

# 支持下标访问和切片

# 他没有推导式，圆括号的是生成器对象

#（生成器对象：一种可迭代的惰性对象generator音标：/ˈdʒen.ə.reɪ.tər/，谐音：珍-呢-瑞-特）

方式	中间对象	内存占用	特性
生成器转元组	生成器	低（惰性）	边遍历边生成，适合大数据
列表推导式转元组	列表	高	先存完整列表，再转元组

my_dict = {"a": 1, "b": 2, "c": 3}
# 生成器 → 转元组（等效“元组推导式”）
new_tuple1 = tuple(f"{key} : {value}" for key, value in my_dict.items())
# 列表推导式 → 转元组
new_tuple2 = tuple([f"{k} : {v}" for k, v in my_dict.items()])

布尔

【逻辑运算】

and与（两个都为真时返回真）、or或（至少一个为真时返回真）、not非（取反）

# 返回的是原值，除了not

# 短路求值优化性能

运算符	Python	Java	JavaScript	说明
逻辑与	and	&&	&&	短路逻辑与
逻辑或	or	||	||	短路逻辑或
逻辑非	not	!	!	逻辑取反
按位与	&	&	&	按位与运算
按位或	|	|	|	按位或运算
按位异或	^	^	^	按位异或运算
按位取反	~	~	~	按位取反运算
左移	<<	<<	<<	左移运算
算术右移	>>	>>	>>	保留符号位的右移
无符号右移	无	>>>	>>>	补0的右移
严格相等	无	无	===	值和类型都相等
严格不相等	无	无	!==	值或类型不相等
非短路与	无	&	无	Java特有的非短路逻辑与
非短路或	无	|	无	Java特有的非短路逻辑或

补充说明：
1. 逻辑运算返回值
Python: 返回原值（非布尔值）
Java: 总是返回 boolean
JavaScript: 返回原值（非布尔值）

2. 位运算整数精度
Python: 无限精度整数
Java: 32位(int)/64位(long)
JavaScript: 32位有符号整数

【比较运算】

==等于、!=不等于、>大于、<小于

# 数字、字符串、列表、元组：完全支持

# 字典、集合：只支持==，!=

运算符/方法	Python	Java	JavaScript	说明
等于	== 实际调用的是__eq__()	==	==	宽松相等
不等于	!=	!=	!=	宽松不相等
严格等于	无	无	===	值和类型都相等
严格不等于	无	无	!==	值或类型不相等
大于	>	>	>	大于比较
小于	<	<	<	小于比较
大于等于	>=	>=	>=	大于或等于
小于等于	<=	<=	<=	小于或等于
身份比较	is	==（对象）	===（对象）	对象身份比较
身份不相等	is not	!=（对象）	!==（对象）	对象身份不相等
值比较方法	__eq__() 默认身份比较，可以自定义	equals()	手动实现	对象值比较

补充说明：
1. python支持链式比较，链式比较就是1<x<2

2.特殊值比较：

<python>

None = None  # True

None is None  # True

float('nan') == float('nan')  # False 因为 NaN != NaN

<java>

null == null  # True

Double.NaN == Double.NaN  # False

Double.isNaN(Double.NaN)  # True

<javascript>

null == undefined  # True

null === undefined  # False

NaN == NaN  # False

NaN === NaN    # False

isNaN(NaN)  # True

列表

my_list=[1,2,3,"a","b","c"]

my_list2=[1,2,3,"a","b","c"]

my_list[1]  #结果2

my_list[10]  # 报错IndexError索引越界

my_list.append("d")  # 末尾添加

my_list.insert(3,4)  # 指定位置插入

my_list.remove(4)  # 删除指定元素

x=my_list.pop()  # 删除并返回最后一个元素 

my_list.count(1)  # 统计1出现的次数

my_list.index(2)  # 找到2第一次出现的位置，找不到会报错ValueError

my_list.reverse()  # 原地反转，my_list变了

my_list.sort()  # 原地排序，my_list变了

my_list[::-1]  # 反转但不修改原来的值

sorted(my_list)  # 排序但不修改原来的值

my_list+my_list2  # 新列表[1,2,3,"a","b","c",1,2,3,"a","b","c"]

my_list.extend(my_list2)  # my_list变为[1,2,3,"a","b","c",1,2,3,"a","b","c"]  原地修改

# 列表支持切片操作

new_my_list=[item +"2" if isinstance(item,str) else item for item in my_list]

# 列表的复制

my_list3=[1,2,[3,4]]

my_list3.copy()  # 浅拷贝

import copy

copy.deepcopy(my_list3)  # 深拷贝（重要对于嵌套列表）

字典

# dict 音标：/dɪkt/  谐音：迪克特

my_dict={"a":"a","b":1}

my_dict2={"c":33}

my_dict.keys() # 得到了所有键["a","b"]

my_dict.values() # 得到了所有值["a",1]

my_dict.pop("a")  # 删除并返回键值

my_dict.update({"c":3})  # 批量更新字典，key没有就添加，有就更新

my_dict.setdefault("c",0)  # 如果键不存在，设置默认值

my_dict|my_dict2  # 字典的快速合并 {"a":"a","b":1,"c":33}

# 批量创建

keys=["a","b","c"]

default_dict=dict.fromkeys(keys,0)

my_dict["c"]=3  # 单个更新字典，key没有就添加，有就更新

print(my_dict["a"])  # 结果a，但是要是my_dict["c"]会报错KeyError，可以添加try安全处理

print(my_dict.get("a"))  # 结果a，my_dict["c"]不会报错

# 遍历字典

for key,value in my_dict.items():

    pass

# 字典推导式

new_my_dictset={f"{key} : {value}" for key,value in my_dict.items()}

推导式类型	语法符号	示例代码	结果类型
集合推导式	{}（无 k:v）	{f"{k}:{v}" for k,v in d.items()}	set（无序）
列表推导式	[]	[f"{k}:{v}" for k,v in d.items()]	list（有序）
字典推导式	{}（有 k:v）	{k:f"{k}:{v}" for k,v in d.items()}	dict（键值对）

集合

# 特点：无序、去重、不可索引（只能遍历随机读取）

# 只能存不可变类型（字符串、数字、元组等），不能存可变类型（列表、字典等）

s={1,2,3}

s.add(4)  # 添加元素

s.remove(1)  # 删除元素（不存在会报错）

s.discard(5)  # 删除元素（不存在不会报错）

s.clear()  # 清空集合

# 集合运算

set1 = {1, 2, 3}

set2 = {3, 4, 5}

set1 | set2   # {1, 2, 3, 4, 5} - 并集

set1 & set2   # {3} - 交集

set1 - set2   # {1, 2} - 差集

set1 ^ set2   # {1, 2, 4, 5} - 对称差集