Python基础（一）
变量的类型及应用方法
变量的类型：
- Numbers（数字）：
* int（有符号整型）
* float（浮点型）
* long（长整型）
* complex（复数）
- Bool类型：
* True（真）
* False （假）
- String（字符串）
- List（列表）
- Tuple（元组）
- Dictionary（字典）
- Set（集合）
查看变量的类型：
type(变量名)
常用的数据类型转换 :
| 函数 |
说明 |
|---|
| int(x) |
将x转换为一个整数 |
| float(x) |
将x转换为一个浮点数 |
| str(x) |
将对象 x 转换为字符串 |
| tuple(s) |
将序列 s 转换为一个元组 |
| list(s) |
将序列 s 转换为一个列表 |
| eval(str) |
用来计算在字符串中的有效Python表达式,并返回一个对象 |
运算符
算术运算符
| 运算符 |
描述 |
实例 |
|---|
| + |
加 |
两个对象相加 a + b 输出结果 30 |
| - |
减 |
得到负数或是一个数减去另一个数 a - b 输出结果 -10 |
| * |
乘 |
两个数相乘或是返回一个被重复若干次的字符串 a * b 输出结果 200 |
| / |
除 |
b / a 输出结果 2 |
| // |
取整除 |
返回商的整数部分 9//2 输出结果 4 , 9.0//2.0 输出结果 4.0 |
| % |
取余 |
返回除法的余数 b % a 输出结果 0 |
| ** |
指数 |
a**b 为10的20次方， 输出结果 100000000000000000000 |
注意：混合运算时，优先级顺序为： ** 高于 * / % // 高于 + - ，为了避免歧义，建议使用 () 来处理运算符优先级。
并且，不同类型的数字在进行混合运算时，整数将会转换成浮点数进行运算。
赋值运算符
| 运算符 |
描述 |
实例 |
|---|
| = |
赋值运算符 |
把 = 号右边的结果 赋给 左边的变量，如 num = 1 + 2 * 3，结果num的值为7 |
| += |
加法赋值运算符 |
c += a 等效于 c = c + a |
| -= |
减法赋值运算符 |
c -= a 等效于 c = c - a |
| *= |
乘法赋值运算符 |
c *= a 等效于 c = c * a |
| /= |
除法赋值运算符 |
c /= a 等效于 c = c / a |
| %= |
取模赋值运算符 |
c %= a 等效于 c = c % a |
| **= |
幂赋值运算符 |
c **= a 等效于 c = c ** a |
| //= |
取整除赋值运算符 |
c //= a 等效于 c = c // a |
比较运算符
| 运算符 |
描述 |
实例 |
|---|
| == |
检查两个操作数的值是否相等，如果是则条件变为真 |
如a=3,b=3，则（a == b) 为 True |
| != |
检查两个操作数的值是否相等，如果值不相等，则条件变为真 |
如a=1,b=3，则(a != b) 为 True |
| > |
检查左操作数的值是否大于右操作数的值，如果是，则条件成立 |
如a=7,b=3，则(a > b) 为 True |
| < |
检查左操作数的值是否小于右操作数的值，如果是，则条件成立 |
如a=7,b=3，则(a < b) 为 False |
| >= |
检查左操作数的值是否大于或等于右操作数的值，如果是，则条件成立 |
如a=3,b=3，则(a >= b) 为 True |
| <= |
检查左操作数的值是否小于或等于右操作数的值，如果是，则条件成立 |
如a=3,b=3，则(a <= b) 为 True |
逻辑运算符
| 运算符 |
描述 |
实例 |
|---|
| and |
布尔"与"：如果 x 为 False，x and y 返回 False，否则它返回 y 的值 |
True and False， 返回 False |
| or |
布尔"或"：如果 x 是 True，它返回 True，否则它返回 y 的值 |
False or True， 返回 True |
| not |
布尔"非"：如果 x 为 True，返回 False 。如果 x 为 False，它返回 True |
not True 返回 False, not False 返回 True |
容器类型的常见操作
通用的操作
| 方法 |
描述 |
|---|
| 序列[位置下标] |
通过下标快速找到对应的数据（字符串、列表、元组） |
| 序列[start: end: 步长] |
用于获取操作对象的局部数据（字符串、列表、元组） |
| + |
连接、拼接数据（字符串、列表、元组） |
| * |
重复（字符串、列表、元组） |
| in |
判断元素是否在 序列 中，如果存在那么结果为true，否则为false（字符串、列表、元组、字典、集合） |
| not in |
判断元素是否不在在 序列 中，如果不存在那么结果为true，否则false（字符串、列表、元组、字典、集合） |
| .len() |
求容器中数据的数量 |
| .max() |
求容器中数据的最大值 |
| .min() |
求容器中数据的最小值 |
| .enumerate() |
枚举出容器中的数据 |
下标：又叫“索引”，默认从0开始
下标和切片需依赖下标，所有操作的数据必须是有序的，如：字符串、列表、元组等
| 类型 |
用法 |
|---|
| 列表推导式 |
new_list = [表达式 for i in … if 条件] |
| 字典推导式 |
new_dict = {key: value for … in …if 条件} |
| 集合推导式 |
new_set = {表达式 for i in …if 条件} |
| 用法 |
描述 |
|---|
| list(序列) |
转列表，有序可改变可重复 |
| tuple(序列) |
转元组, 有序不可变可重复 |
| set(序列) |
转集合，无序可改变不重复 |
| 类型 |
用法 |
描述 |
|---|
| 除字典外 |
for data in dict: print(data) |
遍历数据 |
| 字典 |
for data in dict: print(data) |
遍历key |
| 字典 |
for key in dict.keys(): print(key) |
遍历key |
| 字典 |
for value in dict.values(): print(value) |
遍历value |
| 字典 |
for item in dict.items(): print(item) |
遍历item，以(key,value)形式出现（元组） |
| 字典 |
for key,value in dict.items(): print(key,value) |
遍历item，以key,value形式出现 |
字符串的常用操作
描述：字符串是最常用的数据类型，也称字符序列
字符串定义：‘xxx’ ， “xxx” ， “”“xxx”""， ‘’‘xxx’’’， ‘x"x’ ， “x’x”， “x’x”
| 方法 |
用法 |
描述 |
|---|
| .find() |
mystr.find(str, start=0, end=len(mystr)) |
查找 str 是否在start和end之间，如果是返回开始的索引值，否则返回-1 |
| .rfind() |
mystr.rfind(str, start=0, end=len(mystr)) |
(从右往左)查找 str 是否在start和end之间，如果是返回开始的索引值，否则返回-1 |
| .index() |
mystr.index(str, start=0, end=len(mystr)) |
查找 str 是否在start和end之间，如果是返回开始的索引值，否则会报一个异常 |
| .rindex() |
mystr.rindex(str, start=0, end=len(mystr)) |
(从右往左) 查找 str 是否在start和end之间，如果是返回开始的索引值，否则会报一个异常 |
| .count() |
mystr.count(str, start=0, end=len(mystr)) |
计数：str 在start和end之间在 mystr 里面出现的次数 |
| 方法 |
用法 |
描述 |
|---|
| .replace(old,new) |
mystr.replace(str1, str2, mystr.count(str1)) |
把 mystr 中的 str1 替换成 str2,如果 count 指定，则替换不超过 count 次 |
| .split(分隔符) |
mystr.split(str, maxsplit) |
分割字符串：返回一个列表，丢失分隔符如果 maxsplit有指定值，则仅用 maxsplit 个分隔符分割 |
| 分隔符.join(list) |
mystr.join(str) |
mystr 列表中每个元素后面插入str,构造出一个新的字符串 |
| .partition() |
mystr.partition(str) |
把mystr以str分割成三部分,str前，str和str后，返回一个元组 |
| .rpartition() |
mystr.rpartition(str) |
从右边开始，把mystr以str分割成三部分,str前，str和str后，返回一个元组 |
| .splitlines() |
mystr.splitlines() |
按照行分隔，返回一个包含各行作为元素的列表 |
| 方法 |
用法 |
描述 |
|---|
| .startswith() |
mystr.startswith(str) |
检查字符串是否是以 str 开头, 是则返回 True，否则返回 False |
| .endswith() |
mystr.endswith(str) |
检查字符串是否以 str 结束，是返回True,否则返回 False |
| .isdigit() |
mystr.isdigit() |
如果 mystr 只包含数字则返回 True 否则返回 False |
| .isalpha() |
mystr.isalpha() |
如果 mystr 所有字符都是字母 则返回 True,否则返回 False |
| .isalnum() |
mystr.isalnum() |
如果 mystr 所有字符都是字母或数字则返回 True,否则返回 False |
| .isspace() |
mystr.isspace() |
如果 mystr 中只包含空格，则返回 True，否则返回 False |
| 方法 |
用法 |
描述 |
|---|
| .upper() |
mystr.upper() |
转换 mystr 中的小写字母为大写 |
| .lower() |
mystr.lower() |
转换 mystr 中的小写字母为小写 |
| .capitalize() |
mystr.capitalize() |
把字符串的第一个字符大写 |
| .title() |
mystr.title() |
把字符串的每个单词首字母大写 |
| 方法 |
用法 |
描述 |
|---|
| .strip() |
mystr.strip() |
删除mystr字符串两端的空白字符 |
| .lstrip() |
mystr.lstrip() |
删除 mystr 左边的空白字符 |
| .rstrip() |
mystr.rstrip() |
删除 mystr 字符串末尾的空白字符 |
| 方法 |
用法 |
描述 |
|---|
| .ljust() |
mystr.ljust(width) |
返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串 |
| .rjust() |
mystr.rjust(width) |
返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串 |
| .center() |
mystr.center(width) |
返回一个原字符串居中,并使用空格填充至长度 width 的新字符串 |
列表的常用操作
描述：用于存储批量且可变的有序数据
空列表：[]、list()
列表：list1=[‘A’,‘B’,‘C’]
| 方法 |
用法 |
描述 |
|---|
| .append() |
mylist.append(元素) |
列表尾部增加元素 |
| .insert() |
mylist.insert(index, object) |
在指定位置index前插入元素object |
| .extend() |
mylist.extend(系列) |
将另一个集合中的元素逐一添加到列表中 |
| 方法 |
用法 |
描述 |
|---|
| .remove() |
mylist.remove(数据) |
删除该数据，不返回该值 |
| .pop() |
mylist.pop(index) |
index不指定，默认删除最后一位，并返回该值 |
| .clear() |
mylist.clear() |
清空列表里的元素 |
| del |
del mylist[index]/del list |
删除指定位置数据/删除整个列表变量 |
| 方法 |
用法 |
描述 |
|---|
| list[index] |
mylist[index] = 值 |
修改指定下标的值 |
| .reverse() |
mylist.reverse() |
将mylist的元素逆置 |
| .sort() |
mylist.sort() |
将mylist的元素顺序排序 |
| .sort(reverse=True) |
mylist.sort(reverse=True) |
将mylist的元素逆序排序 |
| 方法 |
用法 |
描述 |
|---|
| .index() |
mylist.index(元素, start=0, end=len(mylist)) |
查找：元素 是否在start和end之间，如果是返回开始的索引值，否则会报一个异常 |
| .count() |
mylist.count(元素, start=0, end=len(mylist)) |
计数：元素 在start和end之间在 mylist 里面出现的次数 |
元组的常用操作
描述：一种存储批量的不可变的有序数据
单个数据：tuple1=(数据1,)
多个数据：tuple1=(数据1，数据2， 数据3…)
| 方法 |
用法 |
描述 |
|---|
| .index() |
mytuple.index(元素, start=0, end=len(mytuple)) |
查找：元素 是否在start和end之间，如果是返回开始的索引值，否则会报一个异常 |
| .count() |
mytuple.count(元素, start=0, end=len(mytuple)) |
计数：元素 在start和end之间在 mytuple 里面出现的次数 |
字典的常用操作
描述：字典就是以键值对方式存储多个数据，键一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一。
空字典：{}、dict()
字典：dict1 = {key1:value1,key2:value2,key3:value3…}
| 方法 |
用法 |
描述 |
|---|
| dict1[key] |
dict1[key] = 值 |
如果这个 key 在字典中，就直接修改 key 对应的值，如果不存在，那么就会新增这个元素 |
| .update() |
dict1.update(dict2) |
把字典dict2的键/值对更新到dict1里 |
| 方法 |
用法 |
描述 |
|---|
| .pop(key) |
dict1.pop(key) |
删除指定 key 的键值对，如果不指定key，默认随机删除一位 ，如果key不存在，会报异常 |
| .popitem() |
dict1.popitem() |
返回并删除字典中的最后一对键和值 |
| .clear() |
dict1.clear() |
清空字典中的元素 |
| del |
del dict1[key]/del dict1 |
删除指定位置数据/删除整个字典变量 |
| 方法 |
用法 |
描述 |
|---|
| dict1[key] |
dict1[key] |
查询指定key，若key不存在，会报错 |
| .get(key) |
dict1.get(key) |
查询指定key，若key不存在，不会报错，返回None |
| .keys() |
dict1.keys() |
查询所有的key，并且输出一个可迭代(遍历)的格式 |
| .values() |
dict1.values() |
查询所有的value，并且输出一个可迭代(遍历)的格式 |
| .items() |
dict1.items() |
查询所有的item，并且输出一个可迭代(遍历)的格式 |
集合的常用操作
描述:集合是一种存储批量无序的不重复数据，集合是可变类型，但里面的元素是不可变类型（可以自动去重复）
空集合：set()
集合：set1 = {数据1， 数据2， 数据3…}
| 方法 |
用法 |
描述 |
|---|
| .add() |
set1.add(数据) |
增加不可改变类型的数据,如字符串、元组等 |
| .update() |
set1.update(系列) |
增加可拆分的系列数据,如字符串、列表等 |
| 方法 |
用法 |
描述 |
|---|
| .remove() |
set1.remove(数据) |
删除指定数据，若数据不存在，会报错 |
| .discard() |
set1.discard(数据) |
删除指定数据，若数据不存在，不会报错 |
| .pop() |
set1.pop(数据) |
不指定数据，默认随机删除一位，若数据不存在，会报错 |
| .clear() |
set1.clear() |
清空集合数据 |
| 方法 |
用法 |
描述 |
|---|
| .union() |
set1.union(set2) |
返回包含一个包含set1和set2所有元素的集 |
| .intersection() |
set1.intersection(set2) |
返回一个包含两个集共有元素的集 |
| .difference() |
set1.difference(set2) |
返回一个集，其中仅包含只出现在set1中的元素，去除共有的元素 |
| .intersection() |
set1.intersection(set2) |
返回一个包含两个集共有元素的集 |
