- 运算符
- 数据类型
- 字符串类型及操作
- 切片
- 列表类型及操作
- 元祖类型及操作
0x01 运算符
- 算术运算符
+ # 加 --> 两对象相加
- # 减 --> 1、负数 2、两个数相减
* # 乘 --> 1、两个数相乘 2、重复前面字符若干次
/ # 除 --> 两数相除
% # 取模 --> 返回两数相除后的"余数"
// # 取整除 --> 返回两数相除后，"商"的整数部分
- 比较运算
== # 等于 ---> 两个对象是否相等
!= # 不等于 ---> 两个对象不相等
<> # 不等于 ---> 两个对象不相等
> # 大于 ---> 左边大于右边
< # 小于 ---> 左边小于右边，返回1为真(True)；返回0为假(False)
>= # 大于等于 ---> 左边大于等于右边
<= # 小于等于 ---> 左边小于等于右边
- 赋值运算
= # 赋值
+= # 加法赋值运算
-= # 减法赋值运算
*= # 乘法赋值运算
/= # 除法赋值运算
%= # 取模赋值运算
//= # 取整除赋值运算
- 位运算
& # 与
| # 或
^ # 异或
~ # 取反
<< # 左移动
>> # 右移动
- 逻辑运算
and # 布尔"与"
or # 布尔"或"
not # 布尔"非"
- 成员运算
in # 若在指定序列中找到值。返回True，否则返回False。
not in # 若在指定序列中没找到值。返回True，否则返回False。
- 身份运算
is # 判断两个标识符，是不是引用一个对象
is not # 判断两个标识符，是不是引用不同对象
0x02 数据类型
Python中，能直接处理的数据类型为: 数值型、字符串型、列表型、元组型、字典型
- 数值类型
分类：整型、浮点型、长整型、复数
2.1 整型
范围: 2**32(2的31次方个正和2的31次方的个负数),包含正数和负数
查看数据类型方法: type()
- 定义字符串
>>> res = "Hello World!"
>>> type(res)
<class 'str'>
>>> date = 20
>>> type(date)
<class 'int'>
2.2 浮点型
带小数点的数，在进行计算时，位数会进行四舍五入
- 定义浮点数
>>> a = 12.3
>>> type(a)
<class 'float'>
>>> b = 15.7
>>> type(b)
<class 'float'>
2.3 长整型
L 或 l 表示，在python3内，已被取消
>>> a = 121211212122222222222222222222222222222222222222222222222222222222222
>>> type(a)
<class 'int'> # python3内，已取消
2.4 复数
j 标识
复数一般用于科学计算，一般不会使用
>>> type(341j)
<class 'complex'>
2.5 类型转换
- 字符串数值转换为浮点型
>>> num = '12'
>>> type(num)
<type 'str'>
>>> float(num)
12.0
- 字符串转换为整形
>>> num = '18'
>>> type(num)
<type 'str'>
>>> num1 = int(num)
>>> type(num1)
<type 'int'>
>>> num1
18
- 整形转换为浮点型
>>> num = 20
>>> type(num)
<type 'int'>
>>> num1 = float(num)
>>> num1
20.0
>>> type(num1)
<type 'float'>
- 浮点型 转换为整形
>>> num = 22.33
>>> type(num)
<type 'float'>
>>> num1 = int(num)
>>> type(num1)
<type 'int'>
>>> num1
22
- round() 返回浮点数x的四舍五入值
格式：
round( x [, n] )
示例:
>>> round(4.567, 2)
4.57
>>> type(a)
<type 'float'>
0x03 字符串类型及操作
3.1 以 单引号 ( ' ) 或 双引号 ( “ ) 括起来的任意对象
3.2 定义字符串：单引号，双引号，三引号
- 字符串定义
str='This is string'
str="This is string"
str='''This is string'''
PS:
三个引号 ( """ )可以是多行注释，但不能单双混合
3.3 字符串方法
- 查找
功能：找到sub在str中的位置，如果找到返回index（匹配到第一个），找不到返回-1
用法：str. find(sub,start=None,end=None)
>>> name = "python"
>>> name.find(3)
>>> name.find("t")
2
- 替换
功能：字符串的替换,把src替换为dst，counter为替换几次
用法：str.replice('src','dst',counter=None)
>>> name = 'Hello python'
>>> name.replice('p','P')
>>> name
Hello Python
- 去除字符串前后空格
功能：去除两边的string,默认是移除空格换行及制表符
用法：str.strip('string')
>>> str = ' Python '
>>> str.strip()
'Python'
- 字符串连接
功能：连接，用于把可迭代对象的每个元素用 什么 连接起来，可迭代对象的元素必须是str
用法：'分隔符'.join(iterable)
>>> str = 'Hello Python'
>>> '_'.join(str)
'H_e_l_l_o_ _P_y_t_h_o_n'
- 分割字符串
功能：把字符串默认从左开始对象使用split进行分割，默认会对所有分割符进行分割，num可以指定分隔符的个数
用法：str.split('split',num=None)
>>> str = 'Hello Python'
>>> str.split('y')
['Hello P', 'thon']
- 格式化字符串
功能：格式化字符串，位置占位符为{0},{1}
用法：str.format()
>>> print('Hello {0}'.format('World'))
Hello World
PS：
采用命名占位符{name},{age},赋值时候需要 name=Mr.Chow,age=18
0x04 切片操作
4.1 字符串是一个序列，可以通过 索引 和 切片 操作
4.2 原则： 前开后闭
- 从第0个开始截取2个字符，其中0可以省略
In [1]: a='abcd'
In [2]: a[0:2]
Out[3]: 'ab'
- 默认是从左往右（前往后），带减号，表示从右往左（后往前），-1表示最后一个字符(a='abcd',-1的值是d，也就是3，顾a[:-1]，就等于a[0:3])
In [4]: a='abcd'
In [5]: a[:-1]
Out[6]: 'abc'
- 从1开始截取到最后
In [7]: a='abcd'
In [8]: a[1:]
Out[9]: 'bcd'
- 步长为2，表示从0开始步长为2，(取0,2,4,6)
In [10]: a='abcd'
In [11]: a[::2]
Out[12]: 'aceg'
- 表示倒着取，从倒数第五个取到倒数第一个（不包含倒数第一，要想取可以使用a[-5:]）
In [13]: a
Out[14]: 'abcdefg'
In [15]: a[-5:-1]
Out[16]: 'cdef'
- 从0开始取到第5个，步长为1，步长为2
In [17]: a
Out[18]: 'abcdefg'
In [19]: a[0:5:1]
Out[20]: 'abcde'
In [21]: a[0:5:2]
Out[22]: 'ace'
- 从后往前取，步长为-1，表示每次倒着取1个，由于没有指定结尾，默认到最后，所以就把数字逆了过来
In [23]: a
Out[24]: 'abcdefg'
In [25]: a[-1::-1]
Out[26]: 'gfedcba'
- 表示先每隔2个取出来，然后从头开始取2个
In [27]: a
Out[28]: 'abcdefg'
In [29]: a[::2][:2]
Out[30]: 'ac'
0x05 列表类型及操作
- 定义
- 方法
- 分片
- 定义
5.1 关键字 --> list，有序集合， 数据可变，[]标识，元素间逗号分隔
- 创建列表
list1 = [] # 创建空列表
list2 = list() # 工厂函数，调用list()内部函数给list2进行赋值
- 创建有值列表
list3 = [1, 'list', True]
- 复杂列表
str = 100
list = ['Chow', str, (11, 43), False, ['Robin', 'Python'], {name: 'Chow', age: 18}]
print(list)
print(type(list))
len(list)
- 方法操作
- 方法：
append # 追加
remove # 删除指定元素
pop # 删除列表最后一位或指定元素，有返回值
reverse # 反转
insert # 数据插入，根据元素下标插入
sort # 排序
- append(追加)
>>> list = [11, 22, 33, 10, 'aa', True]
>>> list.append(100)
>>> list
[11, 22, 33, 10, 'aa', True, 100]
- remove(移除指定元素)
list = [11, 22, 33, 10, 'aa', True]
list.remove(33)
print(list)
[11, 22, 10, 'aa', True]
- pop(删除列表最后一位或指定元素)
list = [11, 22, 33, 10, 'aa', True]
list.pop(-1)
list.pop(0)
print(list)
[22, 33, 10, 'aa']
- del(删除指定元素)
list = [11, 22, 33, 10, 'aa', True]
del list[0]
print(list)
[22, 33, 10, 'aa', True]
- reverse(反转)
list = [11, 22, 33, 10, 'aa', True]
list.reverse()
print(list)
[True, 'aa', 10, 33, 22, 11]
- insert(插入)
list = [11, 22, 33, 10, 'aa', True]
list.insert(2, 'Python')
print(list)
[11, 22, 'Python', 33, 10, 'aa', True]
- sort(排序)
list = [11, 22, 33, 10, 200, 3]
list.sort()
print(list)
[3, 10, 11, 22, 33, 200]
- extend(扩张两个列表)
list1 = [11, 22, 33, 10, 200, 3]
list2 = ["aa", 'bb', 'cc']
list1.extend(list2)
print(list1)
[11, 22, 33, 10, 200, 3, 'aa', 'bb', 'cc']
- 列表循环添加元素
a = list()
for i in range(1, 10):
a.append(i)
print(a)
[1, 2, 3, 4, 5, 6, 7, 8, 9]
- 分片
< 待后期完善 >
0x06 元组类型及操作
- 概念
- 特点
- 定义元祖
- 操作方法
- 概念
6.1 标识 () , 逗号 进行分割。是列表的扩展
6.2 不可变类型
- 特点
6.3 元组值不可改变
6.4 通常用来接收函数的返回值
6.5 可以同时储存不同类型的数据，也可以引用其它元组
- 定义元祖
tuple1 = (11, 22, 33)
type(tuple1)
print(tuple1)
(11, 22, 33)
tuple1 = (11,)
type(tuple1)
print(tuple1)
(11,)
6.6 元祖引用
tuple1 = (11, 22, 33)
tuple2 = ('aa', 'bb', 'cc', tuple1)
type(tuple2)
print(tuple2)
('aa', 'bb', 'cc', (11, 22, 33))
6.7 引用其它元祖内的指定下标元素
tuple1 = (11, 22, 33)
tuple2 = ('aa', 'bb', 'cc', tuple1[2])
print(tuple2)
('aa', 'bb', 'cc', 33)
- 元祖方法操作
6.8 a.count() 统计value在元组中出现的次数，不存在返回0
>>> a = (30, 4, 2, 11, 11, '11', 14, 11)
>>> a.count(11)
3
- index() 用来返回值在元组中的索引下标，若值不存在，则会报错。如果有多个，默认返回第一个（可以指定从哪个索引开始查找到某个索引)
>>> a = ('11', '22', '33', '41')
>>> a.index('22')
1
>>> a = ('a', 'b', 'a', 'b', 'a', 'b', 'a', 'b')
>>> a.index('a', 5, 7)
6