python入门

1. python入门

1.1 基本语法

转义序列

\ \t \r \n ’ "
前缀r，把里面的所有字符当普通字符对待

缩进

缩进的方式表示层次关系，约定使用4个空格缩进

续行

在行尾使用 \
如果使用各种括号，认为括号内是一个整体，内部跨行不用 \

标识符

（1）. 一个名字，用来指代一个值
（2）. 只能是字母、下划线和数字
（3）. 只能以字母或下划线开头
（4）. 不能是python的关键字，例如def、class就不能作为标识符
（5）. Python是大小写敏感的

1.2 Python的语言类型

Python是动态语言、强类型语言
动态编译语言
不用事先声明类型，随时可以赋值为其他类型
编程时不知道是什么类型，很难推断
强类型语言
不同类型之间操作，必须先强制类型转换为同一类型。print(‘a’+1)

2 运算符

2.1 进制

十进制逢十进一；十六进制逢十六进一；二进制逢二进一
转为十进制——按位乘以权累加求和

2.2运算符

(1)算数运算符
整除// ；平方**
(2)位运算符
& 位与,| 位或， ~ 位反， ^异或， << >>
(3)比较运算符
== != > < >= <=
返回一个bool值
(4)逻辑运算符
与或非 and or not
(5)短路运算符
and 如果第一个表达式为False，后面就没有必要计算了，这个逻辑表达式一定是False
or 如果第一个表达式True，后面没有必要计算了，这个逻辑表达式一定是True
(6)赋值运算符
a = min(3, 5)
+= -= *= /= %= 等
x = y = z = 10
(7)成员运算符
in、not in
(8)身份运算符
is 、is not

算数运算符 > 位运算符>身份运算符 > 成员运
算符 > 逻辑运算符
单目 > 双目
记不住，用括号
长表达式，多用括号，
易懂、易读

2.3 原码、反码、补码，负数表示法

反码
正数的反码与原码相同；负数的反码符号位不变其余按位取反
补码
正数的补码与原码相同；负数的补码符号位不变其余按位取反后+1
负数
在计算机中使用补码存储，-1的补码为1111 1111

eg1:~12等于多少，为什么
00001100 #12按位取反
11110011 #最高位是1，当负数处理，认为是负数的补码
10001101 #补码的补码是原码
=-13

eg2:10^9 等于？ 10^-9等于？为什么
1010 #10
1001 #9
0011
=3
00001100 #10
10001010 #-9
10000110
=-3

2.4表达式

Python中，赋值即定义，如果一个变量已经定义，赋值相当于重新定义

3 内存管理

变量无须事先声明，也不需要指定类型，这是动态语言的特性
python使用引用计数记录所有对象的引用数
当对象引用数变为0，它就可以被 垃圾回收GC
计数增加：
赋值给其它变量就增加引用计数，例如x=3; y=x; z=[x, 1]
实参传参，如foo(y)
计数减少：
函数运行结束时，局部变量就会被自动销毁，对象引用计数减少
变量被赋值给其它对象。例如x=3; y=x; x=4

4 程序控制

4.1单分支结构

if语句
if condition:
----代码块
condition必须是一个bool类型，这个地方有一个隐式转换bool(condition)
代码块
类似于if语句的冒号后面的就是一个语句块
在if、for、def、class等关键字后使用代码块

4.2 多分支结构

if…elif…else语句
if condition1:
----代码块1
elif condition2:
----代码块2
elif condition3:
----代码块3
…
else:
----代码块

4.3 分支嵌套

嵌套结构，可以是分支、循环的嵌套
可以互相嵌套多层
多分支结构，只要有一个分支被执行，其他分支都不会被执行
前一个条件被测试过，下一个条件相当于隐含着这个
条件

4.4 循环——for语句*

语法
for element in iterable:
block
当可迭代对象中有元素可以迭代，进入循环体，执行block

4.5 循环–continue语句

中断当前循环的当次执行，继续下一次循环
举例：计算10以内的偶数（for循环）
for i in range(0,10,2): # 减少迭代次数
print(i)
for i in range(0,10): # 使用位与
if i & 1:
continue
print(i)

4.6 循环 break语句

终止当前循环
举例：计算1000以内的正整数被7整除的前20个数（for循环）
count = 1
for i in range(7, 1000, 7):
print(i)
if count == 20:
break
count += 1

4.7循环 continue、break语句

总结
continue和break是循环的控制语句，只影响当前循环，包括while、for循环
如果循环嵌套， continue和break也只影响语句所在的那一层循环
continue和break 不是跳出语句块，所以 if cond: break 不是跳出if，而是终止if外的break所在的循环

5 内置数据结构

5.1 分类

数值型
int、float、complex、bool
序列对象
字符串 str
列表 list
tuple
键值对
集合set
字典dict
数值型

int、float、complex、bool都是class
int：python3的int就是长整型，且没有大小限制，受限于内存区域的大小
float：由整数部分和小数部分组成。支持十进制和科学计数法表示。
complex：有实数和虚数部分组成，实数和虚数部分都是浮点数，3+4.2J
bool：int的子类，仅有2个实例True、False对应1和0，可以和整数直接运算
类型转换（built-in）
int(x) 返回一个整数
float(x) 返回一个浮点数
complex(x)、complex(x,y) 返回一个复数
bool(x) 返回布尔值

5.2 数字的处理函数

round(),四舍六入，偶取整
math.ceil(),向上取整
math.floor(),向下取整
int() 取整数部分
// 整除且向下取整
pow(x,y) 等于 x**y

5.3 类型判断

type(obj) ，返回类型，而不是字符串
isinstance(obj, class_or_tuple)，返回布尔值

6 列表list

（1）一个队列，一个排列整齐的队伍
（2）列表内的个体称作元素，由若干元素组成列表
(3)元素可以是任意对象（数字、字符串、对象、列表等）
(4)列表内元素有顺序，可以使用索引
(5)线性的数据结构
(6)使用 [ ] 表示
(7)列表是可变的

6.1 链表

(1)需要一个一个找
(2)有序的，零散分布
(3)便于数据的增删

6.2 队列

(1)不允许中间增删,只能操作头尾
(2)queue:先进先出队列；地铁
(3)stack:先进后出队列；罗盘子

6.3 列表list定义 初始化

lst = list()
lst = []
lst = [2, 6, 9, ‘ab’]
lst = list(range(5))

6.4 列表索引访问

索引，也叫下标
正索引：从左至右，从0开始，为列表中每一个元素编号
负索引：从右至左，从-1开始
正负索引不可以超界，否则引发异常IndexError
为了理解方便，可以认为列表是从左至右排列的，左边是头部，右边是尾部，左边是下界，右边是上界
list[index] ，index就是索引，使用中括号访问
index(value,[start,[stop]])
通过值value，从指定区间查找列表内的元素是否匹配
匹配第一个就立即返回索引
匹配不到，抛出异常ValueError
count(value)
返回列表中匹配value的次数
时间复杂度
index和count方法都是O(n)
随着列表数据规模的增大，而效率下降

7列表元素修改

7.1 索引访问修改

list[index] = value
索引不要超界

7.2 列表增加、插入元素

append(object) -> None
列表尾部追加元素，返回None
返回None就意味着没有新的列表产生，就地修改
一次增加一个
时间复杂度是O(1)
insert(index, object) -> None
在指定的索引index处插入元素object
返回None就意味着没有新的列表产生，就地修改
时间复杂度是O(n)

超越上界，尾部追加
超越下界，头部追加

extend(iteratable) -> None
将可迭代对象的元素追加进来，返回None
就地修改

• ±> list
  连接操作，将两个列表连接起来
  产生新的列表，原列表不变
  本质上调用的是魔术方法__add__()方法

• *-> list
  重复操作，将本列表元素重复n次，返回新的列表
  (1)x = [[1, 2, 3]]*3
  x[0][1] = 20
  print(x)
  ->
  [[1, 20, 3], [1, 20, 3], [1, 20, 3]]
  (2)y = [1]*5
  y[0] = 6
  y[1] = 7
  print(y)
  ->
  [6, 7, 1, 1, 1]

7.3 列表删除元素

remove(value) -> None
从左至右查找第一个匹配value的值，移除该元素，返回None
就地修改
效率O(n)
pop([index]) -> item
不指定索引index，就从列表尾部弹出一个元素
指定索引index，就从索引处弹出一个元素，索引超界抛出IndexError错误
效率O(1)
clear() -> None
清除列表所有元素，剩下一个空列表
reverse() -> None
将列表元素反转，返回None
就地修改
sort(key=None, reverse=False) -> None
对列表元素进行排序，就地修改，默认升序
reverse为True，反转，降序
key一个函数，指定key如何排序
lst.sort(key=function)
copy() -> List
shadow copy返回一个新的列表
影子拷贝，也叫浅拷贝，遇到引用类型，只是复制了一个引用而已

7.4 随机数

random模块
randint(a, b) 返回[a, b]之间的整数
choice(seq) 从非空序列的元素中随机挑选一个元素 random.choice([1,3,5,7])
randrange ([start,] stop [,step]) 从指定范围内，按指定基数递增的集合中获取一个随机数，基数
缺省值为1。
random.shuffle(list) ->None 就地打乱列表元素
sample(population, k) 从样本空间或总体（序列或者集合类型）中随机取出k个不同的元素，返回

8.元组tuple

一个有序的元素组成的集合
使用小括号 ( ) 表示
元组是不可变对象

8.1元组元素的访问

支持索引（下标）
正索引：从左至右，从0开始，为列表中每一个元素编号
负索引：从右至左，从-1开始
正负索引不可以超界，否则引发异常IndexError
元组通过索引访问
tuple[index] ，index就是索引，使用中括号访问
t[1] = 5

8.2 元组查询

index(value,[start,[stop]])
通过值value，从指定区间查找列表内的元素是否匹配
匹配第一个就立即返回索引
匹配不到，抛出异常ValueError
count(value)
返回列表中匹配value的次数
时间复杂度index和count方法都是O(n)
随着列表数据规模的增大，而效率下降
len(tuple)
返回元素的个数

元组是只读的，所以增、改、删方法都没有

8.3 命名元组namedtuple

namedtuple(typename, field_names,verbose=False, rename=False)
命名元组，返回一个元组的子类，并定义了字段
field_names可以是空白符或逗号分割的字段的字符串，可以是字段的列表

8.4 冒泡法

冒泡法总结
冒泡法需要数据一轮轮比较
可以设定一个标记判断此轮是否有数据交换发生，如果没有发生交换，可以结束排序，如果发生交换，继续下一轮排序
最差的排序情况是，初始顺序与目标顺序完全相反，遍历次数1,…,n-1之和n(n-1)/2
最好的排序情况是，初始顺序与目标顺序完全相同，遍历次数n-1
时间复杂度O(n2)

9 字符串

一个个字符组成的有序的序列，是字符的集合
使用单引号、双引号、三引号引住的字符序列
字符串是不可变对象

9.1 字符串元素访问——下标

字符串支持使用索引访问
sql = “select * from user where name=‘tom’”
sql[4] # 字符串’c’
sql[4] = ’ o’
有序的字符集合，字符序列
for c in sql:
print©
可迭代
lst = list(sql)

9.2 字符串join连接*

“string”.join(iterable) -> str
将可迭代对象连接起来，使用string作为分隔符
可迭代对象本身元素都是字符串
返回一个新字符串

9.3 字符串+连接

• ±> str
  将2个字符串连接在一起
  返回一个新字符串

9.4字符串分割

分割字符串的方法分为2类
split系
将字符串按照分隔符分割成若干字符串，并返回列表
partition系
将字符串按照分隔符分割成2段，返回这2段和分隔符的元组
split(sep=None, maxsplit=-1) -> list of strings
从左至右
sep 指定分割字符串，缺省的情况下空白字符串作为分隔符
maxsplit 指定分割的次数，-1 表示遍历整个字符串
splitlines([keepends]) -> list of strings
按照行来切分字符串
keepends 指的是是否保留行分隔符
行分隔符包括\n、\r\n、\r等
partition(sep) -> (head, sep, tail)
从左至右，遇到分隔符就把字符串分割成两部分，返回头、分隔符、尾三部分的三元组；
如果没有找到分隔符，就返回头、2个空元素的三元组
sep 分割字符串，必须指定

9.5 字符串大小写

upper()
全大写
lower()
全小写
swapcase()
交换大小写

9.6字符串修改*

replace(old, new[, count]) -> str
字符串中找到匹配替换为新子串，返回新字符串
count表示替换几次，不指定就是全部替换
strip([chars]) -> str
从字符串两端去除指定的字符集chars中的所有字符
如果chars没有指定，去除两端的空白字符

9.7 字符串查找*

find(sub[, start[, end]]) -> int
在指定的区间[start, end)，从左至右，查找子串sub。找到返回索引，没找到返回-1
rfind(sub[, start[, end]]) -> int
在指定的区间[start, end)，从右至左，查找子串sub。找到返回索引，没找到返回-1
index(sub[, start[, end]]) -> int
在指定的区间[start, end)，从左至右，查找子串sub。找到返回索引，没找到抛出异常ValueError
rindex(sub[, start[, end]]) -> int
在指定的区间[start, end)，从左至右，查找子串sub。找到返回索引，没找到抛出异常ValueError
count(sub[, start[, end]]) -> int
在指定的区间[start, end)，从左至右，统计子串sub出现的次数

9.8 字符串格式化

***format***函数格式字符串语法——Python鼓励使用
“{} {xxx}”.format(*args, **kwargs) -> str
args是可变位置参数，是一个元组
kwargs是可变关键字参数，是一个字典
花括号表示占位符
{}表示按照顺序匹配位置参数，{n}表示取位置参数索引为n的值
{xxx}表示在关键字参数中搜索名称一致的
{{}} 表示打印花括号

10 bytes、bytearray

bytes是字节组成的有序的不可变序列
bytearray是字节组成的有序的可变序列

10.1 bytes定义

定义
bytes() 空bytes
bytes(int) 指定字节的bytes，被0填充
bytes(iterable_of_ints) -> bytes [0,255]的int组成的可迭代对象
bytes(string, encoding[, errors]) -> bytes 等价于string.encode()
bytes(bytes_or_buffer) -> immutable copy of bytes_or_buffer 从一个字节序列或者buffer复制出一个新的不可变的bytes对象
使用b前缀定义
只允许基本ASCII使用字符形式b’abc9’
使用16进制表示b"\x41\x61"
输入是bytes，输出是bytes

10.2 bytearray定义

定义
bytearray() 空bytearray
bytearray(int) 指定字节的bytearray，被0填充
bytearray(iterable_of_ints) -> bytearray [0,255]的int组成的可迭代对象
bytearray(string, encoding[, errors]) -> bytearray 近似 string.encode()，不过返回可变对象
bytearray(bytes_or_buffer) 从一个字节序列或者buffer复制出一个新的可变的bytearray对象

10.2.1 bytearray操作

和bytes类型的方法相同
bytearray(b’abcdef’).replace(b’f’,b’k’)
bytearray(b’abc’).find(b’b’)
类方法 bytearray.fromhex(string)
string必须是2个字符的16进制的形式，‘6162 6a 6b’，空格将被忽略
bytearray.fromhex(‘6162 09 6a 6b00’)
hex()
返回16进制表示的字符串
bytearray(‘abc’.encode()).hex()
索引
bytearray(b’abcdef’)[2] 返回该字节对应的数，int类型

10.3 字节序

大端模式，big-endian；
小端模式，little-endian
Intel X86 CPU使用小端模式
网络传输更多使用大端模式
Windows、Linux使用小端模式
Mac OS使用大端模式
Java虚拟机是大端模式

尾巴放在低地址端，就是小端模式
LSB:Least Significant Bit，最低有效位
尾巴放在大地址端，就是大端模式
MSB:Most Significant Bit，最高有效位

11 线性结构

11.1 线性结构

可迭代 for … in
len()可以获取长度
通过下标可以访问
可以切片
学过的线性结构
列表、元组、字符串、bytes、bytearray

11.2 切片

通过索引区间访问线性结构的一段数据
sequence[start:stop] 表示返回[start, stop)区间的子序列
支持负索引
start为0，可以省略
stop为末尾，可以省略
超过上界（右边界），就取到末尾；超过下界（左边界），取到开头
start一定要在stop的左边
[:] 表示从头至尾，全部元素被取出，等效于copy()方法
步长切片
[start:stop:step]
step为步长，可以正、负整数，默认是1
step要和start:stop同向，否则返回空序列

11.3 切片赋值

切片操作写在等号左边
被插入值可迭代对象写在等号右边
右边必须是可迭代对象