python基础语法

字符串格式化

• {}占位符：

1. 顺序
"{}, {}".format(s1, s2)
2. 索引
"{2}, {1}".format(s1, s2)
3. key
"{p1}, {p2}".format(p1=s1, p2=s2)

• str = format(num, '格式')

case：

format(123.45, '0.2f')
format(123456.78, ',')	#千分位分隔符
format(123456.78, "0,.2f")	#千分位分隔符

• {:格式}

"{}, {:0,.3f}".format(s, num)

• 早期的格式化输出 %

"%s, %d, %.2f" % (s, num1, num2)

删除空白strip(), lstrip(), rstrip()

字符串查找 find(aim, [start], [end]) || in

字符串替换 replace(ori, aim, [times])

切割字符串

str.split(",")

运算符

• 算术运算符
• 比较运算符
• 逻辑运算符
• 赋值运算符
• 成员运算符
• 身份运算符
• 位运算符

成员运算符 & 身份运算符

成员运算符 in / not：在指定序列中查找

身份运算符 is / is not: 判断两个变量是否引用自同一对象（比较内存地址：是否指向同一内存空间）

位运算符

运算符	作用
&	与
|	或
^	异或
~	取反
<<	左移
>>	右移

字典、列表

四种基本数据结构：

列表（list）

元组（Tuple）

字典（Dictionary）

集合（Set）

列表

索引：

正序：0 ->

倒序：<- -1

切片：范围取值

[start : end : step_len]

.index(e) # 第一次匹配的索引

列表反转

.reverse()

lst.reverse()
print(lst)

列表排序

lst.sort()
print(lst)
lst.sort(reverse=True)  # 降序排序
print(lst)

列表写 增删改查

list.append(new_item)
list.insert(index, new_item)
list[index] = new_item
list[start_index:end_index] = new_list
list.remove(item)
list.pop(index)

• 统计

.count(element)

• 追加一个列表：将new_lst中元素追加到末尾

.extend(new_lst)

• 成员运算符 in / not in 判断是否在列表中

• 创建副本

区别：

new_lst = lst. copy() # new_lst is not lst

new_lst = lst # new_lst is lst，简单的引用（指向原空间）

• 清空列表

.clear()

多维列表（嵌套列表）

lst = ['fjj', 'hp', 'tq', 'yxy']
print(lst[0])
print(lst[-4])

print(lst[:3:2])
print(lst[::2])
print(lst[1::3])
print(lst[-1: -3: -1])
print(lst[-3: -1: 1])

print(lst.index('fjj'))

lst.reverse()
print(lst)
lst.sort()
print(lst)
lst.sort(reverse=True)  # 降序排序
print(lst)
lst[1:3] = lst[2:0:-1]
print(lst)

lst[1:3] = []
print(lst)

print('yxy' not in lst)

字典（Dictionary）

列表在表达结构化数据(key: value，有明确属性) 时语义不明确，

python中的内置数据结构

字典可修改，运行时动态调整存储空间

创建字典的两种方式

{‘key’ : value}

dict(key=value) (key默认字符串，不需要加’’)

通过列表创建：

dict.fromkeys(key列表, [默认初始值,缺省为None])

dict1 = {
    'name' : 'xxx',
    'height' : 175,
    'weight' : 80
}
print(dict1)

dict2 = dict(name='xxx', height=175, weight=80)
print(dict2)

dict3 = dict.fromkeys(['fjj', 'hp', 'yxy'], 'N/A')
print(dict3)

字段的取值

[]

get(key, [若不存在返回的结果,缺省为None])

print(dict1.get('name'))
print(dict1.get('sex'))
print(dict1.get('sex', 'F'))

遍历字段

for key in dict1:
    value = dict1[key]
    print(key, value)

for key, value in dict1.items():
    print(key, value)

字典更新 & 删除

字典更新 & 删除

[] = new_value

批量更新：update(key1=new_v1, key2 = new_v2)

dict1.update(sex='F', height=190)

删除：

pop(key)

kv = popitem() 删除最后一个kv

clear() ： 清空字典

dict1.pop('name')
print(dict1)
kv = dict1.popitem()
print(kv)
dict1.clear()
print(dict1)

字典常用操作

为字典设置默认值

setdefault(key, value)

字典的视图

keys(): 获取所有的键

values(): 获取所有值

items()：获取所有键值对

返回的都是包装过的list（dict_）：原因 -> 字典的视图对象，随着字典的类型随时发生变化

字典的格式化输出

利用字典格式化字符串:

老版本：

print("%(name)s, %(height)d, %(weight)d" % dict1)

新版本：

print("{name}, {height}, {weight}".format_map(dict1))

字典底层 Hash

数字指纹

hash(_obj) : 将任一对象映射到一个hash值

字典在项目中的应用

python中非可变类型： 元组 & 集合

元组：不可变的列表 () # 括号可省略

元素创建后不可修改，但可以通过 元组运算符 来创建新的元组

写：本身元素不可修改

特殊情况：元组中包含列表，列表可修改

t = ([0, 1, 2], [3, 4, 5])
t[0].append(8)
print(t)
t[0][1] = 99
print(t)

元组运算符：同样适用于列表

print([0] * 5)

+：内存开辟新空间，放入原来的两个元组元素

*n：重复n次

[特殊] 如果元组中只有一个元素时，必须在其后添加，说明其为一个元组，否则会被当做普通变量

元组与列表的区别

list	tuple
允许扩展	内容不可变
内存存储动态变化	创建后固定不变
效率较低	效率最高
运行时数据需要变更时使用	用于保存稳定不变的数据
保存天气数据、股市数据	保存国家名、元素周期表

列表：内存连续空间

序列 sequence

有序的队列: 有序 + 索引

包含：字符串，列表，元组，数字序列（Range）

数字序列 range

内容不可变

range(start, end, [step_len])

序列类型转换list(), tuple(), join() / str(), split()

tuple(list): 列表 -> 元组

str()：将单个变量转化为字符串

join(): 对列表元素进行连接， “元素间的分隔符”.join([‘a’, ‘b’, ‘c’])

【注】必须要求所有元素都是字符串

集合

没有Value的字典，使用{}

1. 无序
2. 不重复
3. 可变
4. 允许集合数学运算
5. 内存中分散存储（Hash）

集合的创建

1. {}
2. set(list)：用list创建
3. set(“str”): 用str创建，每个字符的集合
4. 空集合：{} 错误（默认定义为字典） --> set()

集合的数学运算

交（Intersection）

set3 = set1.intersection(set2)

set1.intersection_update(set2)

并（Union）

set3 = set1.union(set2)

差（Difference）

set3 = set1.difference(set2)
set1.difference_update(set2)

异或：

set3 = set1.symmetric_differece(set2)
set1.symmetric_differece_update(set2)

集合间的关系操作

==:

包含：

set1.issubset(set2)	# 子集
set2.issuperset(set1)	# 父集

集合间是否有重复(交集)

set1.isdisjoint(set2)	# True不存在， False存在

集合增删改查

增：

.add()：一次只能添加一个元素

.update()：一次可添加多个元素(list)

删：

.remove(): 删除不存在的元素会报错

.discard(): 删除不存在的元素则跳过

三种内置生成式

语法:

[被追加的数据 循环语句（外层） 循环（内层）或判断语句] | {}

列表生成式

lst = [i for i in range()]

lst2 = [i for i in range() if i % 2 == 0]
==>
for i in range():
	if i % 2 == 0:
        lst2.append(i)

字典生成式

dict = {i+1:lst[i] for i in range(len(lst))}

集合生成式

set = {i * j for i in range(4) for j in range(4) if i == j}