基础语法
变量 & 语句
变量命名规则
英文大小写字母、数字、下划线组成
不能以数字开头
不能是关键字、保留字
变量名称区分大小写
语句
varname = value # 赋值语句
print(value,value2,value3...) # 打印语句
varname = input('prompt') # 控制台输入语句数据类型
数值类型
整型、浮点型、字符串型、布尔型
字符串
用单引号、双引号、三个(单|双)引号引起来的一堆字符
布尔类型
表示真和假； 真：True 假：False
类型转换
整型 => 浮点 float(1) ==> 1.0
整型 => 字符 str(1) ==> "1"
整型 => 布尔 bool(1) ==> True 非 0 为True， 0 为False
浮点 => 整型 int(1.0) ==> 1
浮点 => 字符 str(1.0) ==> '1.0'
浮点 => 布尔 bool(1.0) ==> True 非 0 为True， 0 为False
布尔 => 整型 int(True) ==> 1 int(False)==> 0
布尔 => 字符 str(True) ==> "True" str(False) ==> "False"
布尔 => 浮点 float(True)==> 1.0 float(False)==> 0.0
字符 => 整型 int('1') ==> 1 只能为数字，否则错误： ValueError
字符 => 浮点 float('1') ==> 1.0 只能为数字，否则错误： ValueError
字符 => 布尔 bool('1') ==> True运算
四则运算
数值
+ - * / % ** // 其中 / 和 // 被除数不能为0
字符串
+ 左右操作必须为字符串： 'abc' + 'def' = 'abcdef' '1' + '1' = '11'
* 其中一个为字符串，另一个为整数 '1' * 2 = '12'
bool
需转换成 int 进行四则运算
布尔运算
与 ==> and 含义： 只有两个为 True 结果为 True
或 ==> or 含义： 只要一个为True 结果为True
非 ==> not 含义：你真我假，你假我真
关系运算
> 、< 、>=、<=、==、!=
控制语句
条件
if cond_1:
code_1
elif cond_2:
code_2
....
elif cond_n:
code_n
...
else:
else_code
# 结果
1,2,3=>False, 4=> True
code_4
1,3=>False, 2, 4=>True
code_2
1,2, n=>False
else_code循环
while cond:
while_code
# 语句控制
break 跳出循环
continue 跳过本次循环，下次继续序列
列表
类型名
list
语法
nums = [1,2,3,4]操作
# 元素的访问
1. 从左到右 或者 从右到左
2. varname[idx]
varname[idx] = value # 元素的修改
del varname[idx] # 元素的删除
value in varname # 元素是否再元素中
for value in varname # 遍历元素
max(varname) # 获取最大元素
min(varname) # 获取最小元素
len(varname) # 获取长度运算
# 加 ===> 左操作数，右操作数都为列表
>>> [1,2] + [3,4]
[1, 2, 3, 4]
# 乘 ===> 左操作数和右操作数一个为整数一个为列表
>>> [1,2] * 3
[1, 2, 1, 2, 1, 2]range
range(start, end, step) # 语法；由所有元素start + n * step组成的一个可遍历的数据结构。
>>> range(1,10,2) # 从开始到结尾，步长为2，得到列表组合
[1, 3, 5, 7, 9]
>>> range(1,10)
[1, 2, 3, 4, 5, 6, 7, 8, 9]类型转换
list(varname) # varname需要是可遍历的
>>> list([1,2,3])
[1, 2, 3]切片
# 例如： varname = [1,2,3,4,5,6,7]
varname[start:end:step] # 由varname中索引为start+n*step对应的元素组成的列表 n自然数 [start, end]
varname[start:end] # 获取 `开始` 到 `结尾` 之间的数据
varname[:end] # 获取以 end 索引结束，前面所有的数据
varname[:] > [1, 2, 3, 4, 5, 6, 7] # 省略全部，代表截取全部内容，可以用来将一个列表拷给另一个列表
varname[:2] > [1, 2] # 省略起始位置的索引，以及步长。默认起始位置从头开始，默认步长为1，结束位置索引为2
varname[::2] > [1, 3, 5, 7] # 省略起始位置的索引,步长为2,结束位为默认到结尾
varname[1::2] > [2, 4, 6] # 索引起始1，步长为2，结束位默认到结尾
varname[::-1] > [7, 6, 5, 4, 3, 2, 1] # 反向排序
varname[::-2] > [7, 5, 3, 1] # 反向排序，步长为2,结束位默认到结尾
varname[5:0:-1] > [6, 5, 4, 3, 2] # 反向排序，取值0~5的索引
varname[-2::-2] > [6, 4, 2] # 反向排序，步长为2,开始位置以结尾第2个索引开始，结束为开头位置
varname[0:-1:1] > [1, 2, 3, 4, 5, 6] # 从位置0开始到结束，每次增加1，截取。不包含结束索引位置
varname[0:7:3] > [1, 4, 7] # 从第一个位置到第7个位置，每3个取一个值
# 赋值
varname[start:end] = []函数
帮助查询： dir || help
List = [1,2]
# append
>>> List.append(3) ===> 追加到列表尾部 ===> [1,2,3]
# clear 不支持python2
>>> List.clear() ===> 清空列表 ===> []
# copy
>>> List2 = var.copy() ===> 复制列表 ===> List2 = [1,2]
# count
>>> List.count(2) ===> 返回列表中数字 2 出现的次数，如果没有数据，则返回0 ===> 1
# extend
>>> List.extend([3,4]) ===> 合并列表，添加到var末尾 ===> [1,2,3,4]
# index
>>> List.index(1) ===> 获取数据在列表中的索引位置 ====> 0
# insert
>>> List.insert(100,4) ===> 索引100处插入一个元素4 ===> [1,2,4]
# pop
>>> List.pop(1) ===> 弹出索引位置元素,通过索引删除该元素并返回，如果不指定则删除最后一个 ===> [1]
# remove
>>> List.remove(1) ===> 通过索引删除该元素并返回 ===> [1]
# reverse
>>> List.reverse() ===> 反转列表中的所有元素位置 ===> [2,1]
# sort
>>> List.sort() ===> 将列表进行重新排序,升序排列 ===> [1,2]
>>> List.sort(reverse=True) ===> 倒序排列 ===> [2,1]元组
语法
nums =(1, 2, 3, 4, [])
一个元素时，最后的逗号不能省略
不可变
不可变的列表
索引对应的值/指向(数据结构)不可变
tuple[index] = value
报错
tuple[index].append(value)
不报错字典
基本用法
DICT = {'语文': 89, '数学': 93, '英语': 5.7}
DICT['语文'] # 通过 key 访问 value 。
DICT['物理'] = 90 # 通过 key 添加 key-value 对，如果已存在，就修改key-value对
del DICT['物理'] # 通过 key 删除 key-value 对。
'语文' in DICT # 通过 key 判断指定 key-value 对是否存在。常用方法
DICT = {'语文': 89, '数学': 93, '英语': 5.7}
# 查看字典中包含那些方法： dir(dict)
max() => 获取成绩最高的科目 ===> v,k = max(zip(DICT.values(),DICT.keys()))
min() => 获取成绩最低的科目 ===> v,k = min(zip(DICT.values(),DICT.keys()))
len() => 获取字典长度 ===> len(DICT)
clear() => 清空字典 ===> DICT.clear() ===> {}
copy() => 复制字典 ===> DICT2=DICT.copy()
fromkeys() => 给多个 key 创建字典，默认 None,也可传入一个默认value ===> dict.fromkeys((13, 17), 'good') ===> {13: 'good', 17: 'good'}
get() => 通过key 来获取 value ===> DICT.get('语文') ===> 89
pop() => 获取指定 key 对应的 value，并删除这个 key-value ===> DICT.pop('语文') ===> {'数学': 93, '英语': 5.7}
update() => 更新己有的字典,如果存在，覆盖，反之添加 ===> DICT.update({'物理':4.5})
items() => 获取所有 key-value => DICT.items() ===> 返回 dict_items 对象 ===> list() 函数把对象转换成列表
>>> list(DICT.items()) >>> [('语文', 89), ('数学', 93), ('英语', 5.7)]
keys() => 获取所有 key ===> DICT.keys() => 返回 dict_keys 对象 ===> list() 函数把对象转换成列表
>>> list(DICT.keys()) >>> ['语文', '数学', '英语']
values() => 获取所有 value ===> DICT.values() => 返回 dict_values 对象 ===> list() 函数把对象转换成列表
>>> list(DICT.values()) >>> [89, 93, 5.7]
popitem() => 删除字典最后一个 key-value
>>> DICT.popitem() # 删除返回元组，可通过 k,v = DICT.popitem() 方式赋值获取 key 和 value 值
('英语', 5.7)
>>> DICT
{'语文': 89, '数学': 93}
setdefault()=> 先判断是否存在key,如果不存在，就设置默认的 key-value值
>>> DICT.setdefault('语文',80)
89 # 如果存在，就返回字典中值
>>> DICT.setdefault('物理',80)
80 # 如果不存在，就返回给设定的值
>>> DICT
{'语文': 89, '数学': 93, '英语': 5.7, '物理': 80}遍历四法
var = {'a': '1', 'b': '2', 'c': '3'}
# 根据 key 值遍历
for key in var.keys():
print(key+':'+var[key])
# 根据 value 遍历， 只输出 value 值
for value in var.values():
print(value)
# 根据字典项遍历，输出每个字典项的元组
for kv in var.items():
print(kv)
# 根据字典键值对遍历
for key,value in var.items():
print(key+':'+value)字符串
特殊字符
\ ===> 转义
\n ===> 换行
\r ===> 回车
\t ===> tab键
\f ===> 换页遍历字符
strs = 'abcdefg'
for s in strs:
print(s)基操
strs = 'abcdefg'
max() ===> 最大值 ===> max(strs) ===> 'g'
min() ===> 最小值 ===> min(strs) ===> 'a'
len() ===> 长度 ===> len(strs) ===> 7count() ===> 计算字符串中出现子字符串的次数 ===> str.count('str')
index() ===> 计算字符串中出现子字符串位置索引，若不存在则报错 ===> str.index('str')
find() ===> 计算字符串中出现子字符串位置索引，若不存在则返回-1 ===> str.find('str')
startswith/endswith ===> 判断字符串是否以参数开头/结尾, 返回 True or False ===> str.startwith('str') or str.endswith('str')
format ===> 格式化字符串 ===> 'My name is {}'.format('Tom')
lower/upper ===> 将字符串转成小写/大写 ===> str.lower() 【小写】 or str.upper() 【大写】
replace ===> 替换字符串 ===> str.replace('source','dest')
join ===> 使用字符串连接序列 ===> li = [1,2] ===> ':'.join(li) ===> 1:2
split/splitlines ===> 分隔字符串为list ===> strs = 1:2 ===> strs.split(':') ===> [1,2]
strip ===> 去除字符串前后的空字符 ===> strs = " abc 123 " ===> strs.strip()
# 假如 s 为字符串, 判断结果为 True or False
s.isalnum() 所有字符都是数字或者字母
s.isalpha() 所有字符都是字母
s.isdigit() 所有字符都是数字
s.islower() 所有字符都是小写
s.isupper() 所有字符都是大写
s.istitle() 所有单词都是首字母大写，像标题
s.isspace() 所有字符都是空白字符、\t、\n、集合
定义： 没有重复不可变的元素的无序的list 由字典的key组成的一种数据结构 由{}包含，每个元素用逗号分割，元素不可变set() 特性： 无序、元素不重复、可遍历
运算
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a
{'a', 'r', 'b', 'c', 'd'}
>>> a - b # 集合a中包含而集合b中不包含的元素 差集
{'r', 'd', 'b'}
>>> a | b # 集合a或b中包含的所有元素 并集
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b # 集合a和b中都包含了的元素 交集
{'a', 'c'}
>>> a ^ b # 不同时包含于a和b的元素 对差集
{'r', 'd', 'b', 'm', 'z', 'l'}
min、max、sum、len、in
>>> min(a)、max(a)、sum(a)、len(a)、'a' in a方法
# add 添加元素： 参数可以是列表，元组，字典等
>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.update({1,3})
>>> thisset.update([1,4],[5,6])
>>> thisset.add("Facebook")
>>> print(thisset)
{1, 3, 4, 5, 6, 'Taobao', 'Runoob', 'Facebook', 'Google'}
# remove 删除元素
>>> thisset.remove(1)
>>> print(thisset)
{3, 4, 5, 6, 'Taobao', 'Runoob', 'Facebook', 'Google'}用途
主要用在元素去重
Last updated