声明

该文章都是摘自一些视频的笔记和一些博客！
http://www.cnblogs.com/jin-xin/articles/7459977.html

---

0x01 python种类

CPython

当我们从Python官方网站下载并安装好Python3.6后，我们就直接获得了一个官方版本的解释器：CPython
这个解释器是用C语言开发的

在命令行下运行python就是启动CPython解释器

IPython

是基于CPython之上的一个交互式解释器

Cpython用：>>>作为提示符
IPython用：In[序号]：作为提示符

PyPy

是另一个Python解释器，它的目标是执行速度

PyPy采用JIT技术，对Python代码进行动态编译（注意不是注释）

绝大部分Python代码都可以在PyPy下运行，但是PyPy和CPython有一些不同

这就导致相同的python代码再两种解释器下执行可能会有不同的结果

Jython

运行在Java平台上的Python解释器，可以直接把Python代码编译成Java字节码执行

IronPython

运行在微软.Net平台上的Python解释器，可以直接把Python代码编译成.Net的字节码

小结

Python的解释器很多，但使用最广泛的还是CPython。如果要和Java或.Net平台交互，最好的办法不是用Jython或IronPython，而是通过网络调用来交互，确保各程序之间的独立性

---

0x02 变量

变量是为了存储信息被调用，并且还提供方式标记,数据,描述性理解更清晰

变量在程序中就是用一个变量名表示
变量名必须是大小写英文,数字和_的组合，且不能用数字开头

a = 1
t_007 = '007' #这个一个字符串

等号=是赋值语句,把任意数据类型赋值给变量,同一个变量可以反复赋值，而且可以是不同类型的变量

a = 123
print(a) #a是整数

a = 'abc' #a变为字符串
print(a)

变量本身类型不固定的语言称之为动态语言，与之对应的是静态语言

静态语言在定义变量时必须指定变量类型，如果赋值的时候类型不匹配,就会报错

最后理解在计算机内存中的表示也非常重要,当我们写：

a = 'ABC'

Python解释器干了两件事

• 在内存中创建了一个’ABC’的字符串
• 在内存中创建了一个名为a的变量,并把它指向’abc’

变量定义规则

• 变量名只能是 字母、数字或下划线的任意组合
• 变量名的第一个字符不能是数字
• 以下关键字不能声明为变量名

  and, as, assert, break, class
  continue, def, del, elif, else
  except, exec, finally, for, from
  global, if, import, in, is
  lambda, not, or, pass, print
  raise, return, try, while, with, yield

推荐定义方式

• 驼峰体

AgeOfOldboy = 56

NumberOfStudents = 80

• 下划线

age_of_oldboy = 56

number_of_students = 80

---

0x03常量

所谓常量就是不能变的变量，比如常用的数字常数π就是一个常量

在Python中,通常用全部大写的变量名表示常量

PI = 3.15159265359

事实上任然是一个常量,在Python根本没有任何机制保证PI不会被改变
所以,用全部大写的变量名表示常量只是一个习惯上的用法

python是不区分常量和变量的

---

0x04 字符编码

python解释器在加载.py文件中代码时,会对内容进行编码(默认ascill)
ascii码无法将世界上的各种文字和字符全部显示，所以就需要新出一种可以代表所有字符和符号的编码 即:unicode

Unicode

Unicode(统一码,万国码)是一种在计算机上使用的字符编码

Unicode是为了解决传统的字符编码方案的局限而产生的
他为每种语言中的每个字符设定了统一并且唯一的二进制编码,规定虽有的字符和符号最少由16位来表示(2字节) 2**16 = 65536

utf-8

utf-8 是对Unicode编码的压缩和优化,它不再使用最少使用2个字节,而是将所有的字符和符号进行分类

python2.x/3.x 默认编码

ASCII码中的内容用1个字节保存
欧洲的字符用2个字节保存
东南亚的字符用3个字节保存。。。

所以,python解释器在加载.py文件中的代码时,会对内容进行编码(默认为ascill)
而输入中文的话,会报错(ASCII码无法支持中文)

ASCII ==> GB2312 ==> gbk1.0 ==> gb18030
ASCII ==> Unicode ==> utf-8

Python2.x == ASCII 默认编码
Python3.x == Unicode 默认编码

---

0x05 注释

• 单行注释

# 被注释的内容

• 多行注释

'''
被注释内容
'''

或

"""
被注释内容
"""

---

0x06 输入/输出

print

用print()在括号中加上字符串,就可以向屏幕上输出指定的文字

print("hello")

可以接受多个字符串，用,逗号隔开,就可以连成一串输出

print("The quick brown fox",'jumps over','the lazy dog')

print()会依次打印每个字符串

遇到逗号,会输出一个空格

input

input()可以让用户输入一个字符串,并放到一个变量里

name = imput()

---

0x07 数据类型

整数

python可以处理任意大小的整数,包括负整数

例如: 1,-1,8080 等等之类的数字

计算机由于使用二进制，所以有时候用十六进制表示整数比较方便，十六进制0x开头

浮点数

浮点数也就是小数
浮点数运算则可能会有四舍五入的误差

name = 0.00001

字符串

字符串是以单引号'，或双引号"括起来的任意文字

Tips：''或""本身只是一种表示方式,不是字符串的一部分

name = 'my name'

字符串拼接

Tips：字符串的拼接只能是双方都是字符串，不能跟数字或其他类型拼接

• +

name = "xiao san"
age = "22"

print("小三的信息是："+name+age)

• *

name = "xiao san"
age = "22"

# 相城就是复制自己多次再拼接在一起
print(name * 10)

格式化输出

只要把要打印的格式先准备好，由于里面的一些信息是需要用户输入的，你没办法预设知道
因此可以先放置个占位符，再把字符串里面的占位符与外部的变量做个映射关系

% 占位符

格式化输出字符串:%

占位符	替换内容
%d	整数
%f	浮点数
%s	字符串
%x	十六进制整数
%%	输出第二个百分号

例如：让用户输出用户信息

name = input("Name:")
age = input("Age:")
job = input("Job:")
hobbie = input("Hobbie:")

info = '''
------------ info of %s -----------
Name  : %s
Age   : %s
job   : %s
Hobbie: %s
------------- end -----------------''' %(name,name,age,job,hobbie)
print(info)

format()

格式化输出字符串:format()
他会用传入的参数一次替换字符串的占位符{0},{1}….

name = 'admin'
print('{}'.format(name))

• 三种玩法

res='{} {} {}'.format('egon',18,'male')
res='{1} {0} {1}'.format('egon',18,'male')
res='{name} {age} {sex}'.format(sex='male',name='egon',age=18)

转义字符

转义字符\,可以转义很多字符

转义字符	含义
\n	换行符
\t	制表符
\	反斜线”\ “

如果字符里面很多字符都需要转义,为了简化
python还允许用r' '表示' '内部的字符串默认不转义

print(r'/t')|

如果字符串内有很多换行,为了简化
python运行用 '''.......'''的格式表示多行内容

print('''
lin1
lin2
''')

多行字符串'''.....''',还可以在前面加上r使用

字符串的切片与索引

索引

• 索引即下标，就是字符串组成的元素从第一个开始，初始索引为0以此类推

a = 'ABCDEFGHIJK'
print(a[0])
print(a[1])

切片

• 切片就是通过索引（索引:索引:步长）截取字符串的一段，形成新的字符串

a = 'ABCDEFGHIJK'

print(a[0:3])
print(a[2:5])
print(a[0:])    # 默认到最后
print(a[0:-1])  # -1就是最后一个

字符串常用方法

• 首字母大写

capitalize()

• 大小写翻转

swapcase()

• 每个单词的首字母大写

title()

• 内容句容，总长度，空白处填充

# 第二个为填充内容，不填默认为空白
center(20,"*")

• 计算长度

len()

• 判断是否以…开头

startswith()

• 判断是否以…结尾

endswith()

• 寻找字符串中的元素是否存在

find

find(sub[,start=0[,end=len(S)]])

参数说明：

• sub – 指定检索的子字符串
• start – 可选参数，开始索引，默认为0（可单独指定）
• end – 可选参数，结束索引，默认为字符串长度（不能单独指定）

tips：返回子字符串的第一个匹配项出现在字符串中的索引位置，如果没有匹配性则返回-1

index

index(str, beg=0, end=len(string))

参数说明：

• sub – 指定检索的字符串
• beg – 开始索引，默认为0
• end – 结束索引，默认为字符串的长度

tips： 如果包含子字符串返回开始的索引值，否则抛出异常

• 分割

  split()

• 去除首位字符

  strip()

• 替换字符串

  replace(old, new[, max])

  参数说明：

• old – 将被替换的子字符串

• new – 新字符串，用于替换old子字符串

• max – 可选字符串，替换不超过max次

布尔值

布尔值只有true和false两种值

空值

空值是Python里的一个特殊的值,用None表示
None不能理解为0,因为0是有意义的

---

0x08 流程控制

条件判断语句

if

if (判断条件):
    满足条件后要执行的代码

例如：判断小李的年龄是否为22

age = 22
if (age == 22):
    print('小李的年龄是：%s'%(age))

if …else

if (条件):
    为真则执行这段代码
else:
    if条件为假执行的代码

例如：判断小李的年龄是否为22，为真打印，为假输出骗子

age = 33
if (age == 22):
    print('小李的年龄是：%s'%(age))
else:
    print("我是骗子，来打我啊")

if…else…

可以有多个分支条件

if 条件:
    满足条件执行代码
elif 条件:
    上面的条件不满足就走这个
elif 条件:
    上面的条件不满足就走这个
elif 条件:
    上面的条件不满足就走这个    
else:
    上面所有的条件不满足就走这段

while

while 条件:
    # 循环体

    # 如果条件为真，那么循环体则执行
    # 如果条件为假，那么循环体不执行

循环中止语句

• break,用于完全结束一个循环，跳出循环体执行循环后面的语句

count = 0

while count <= 100:
    print("loop ",count)
    if count == 5:
        break
    count +=1
print("-----out of while loop ------")

• continue只是终止本次循环，接着还执行后面的循环

count = 0

while <= 100:
    count += 1
    if count > 5 adn count <95:
        continue
    print("loop ",count)
print("-----out of while loop ------")

while…else

Tips：当while循环被break打断，就不会执行else的结果

while 后面的else作用是指，当while循环正常执行完，中间没有被break中止的话，就会执行else后面的语句

count = 0

while count <= 5:
    count += 1
    print("loop ",count)
else:
    print("循环正常执行完")
print("-----out of while loop ------")

while例子

• 求 1-100的所有数的和

i = 0
count = 1

while i <= 100:
    count += i
    i += 1
print(count)

• 输出1-100内的所有奇数

count = 0

while count <= 100:
    count += 1
    if (count%2 != 0):
        print(count)

• 输出1-100内所有的偶数

count = 0

while count <= 100:
    count += 1
    if (count%2 == 0):
        print(count)

• 求 1-2+3-4+5…9的所有数的和

count = 0
sum = 0

while count < 100:
    if (count%2 == 0):
        sum = sum - count
    else:
        sum = sum +count
    count += 1
print(sum)

# 说明
当count为偶数的时候，进行1-2等运算，若不是偶数，则进行sum+count

• 用户登录(三次机会)

admin = 'admin'
passwds = 'pass'
count = 1

while count <= 3:
    name = input("name：")
    passwd = input("password：")
    if ((name == admin) and (passwd == passwds)):
        print("登录成功")
        break
    else:
        count +=1
        print("\n 用户或密码不正确，请重新输入 \n")
else:
    print("登录失败")

for 循环

for循环可以遍历任何序列的项目，如一个列表或者一个字符串

for ... in ....

例如：遍历一个python

a = 'python'
for i in a:
    print(i)

---

0x09 运算符

算数运算符

这里就不过多说明了，我在这里就列个表

运算符	描述
+	加
-	减
*	乘
/	除
%	取模，返回除法的余数
**	幂，返回x的y次幂
//	取整除，返回商的整数部分

比较运算符

运算符	描述
==	等于
!=	不等于
<>	不等于
>	大于
<	小于
>=	大于等于
<=	小于等于

赋值运算符

运算符	描述
=	赋值
+=	加法赋值运算符
-=	减法赋值运算符
*=	乘法赋值运算符
/=	除法赋值运算符
%=	取模赋值运算符
**=	幂赋值运算符
//=	取整赋值运算符

# 例子
c += a  ===> c = c+a

逻辑运算符

运算符	描述	返回
and	与	两边为真，才为真
or	或	只要有一个为真，则为真
not	非	取反，真为假，假为真

tips 1：在没有()的情况下，not优先级高于and，and优先级高于or，即()>not>and>or
tips 2：布尔值为0，false，不为0，true
tips 3：布尔值真假，可以转换为1和0

短路原则

• and的第一个条件为假，后面的不管怎样都为假
• or的第一个条件为真，湖面的不管为什么都为真

# x and y ,x 为 true，则返回y
print(1 and 2)  #2

# x or y，x为true，则返回x
print(3 or 100 or 5 or 2) # 3

---

0x10 元组（tupe）

元组被称为只读列表，即数据可以被查询，但不能被修改

• 定义一个空的tuple,可以写成(),只有一个元素的tuple定义时必须加一个逗号,

x =() #定义空的tuple

x = (1,) 
print(x)

tuple一旦初始化就不能修改

x = ('Michael', 'Bob', 'Tracy')

t = ('a', 'b', ['A', 'B'])
t[2][0] = 'X'
t[2][1] = 'Y'

• tuple的陷阱:当你定义一个tuple时,在定义的时候.tuple的元素就必须被确定下来

修改元组中的列表

a = (1,2,3,4,5,6,[7,8,9,10],11,12,13)
a[6][0] = '你大爷'
print(a)

---

0x11 列表（list）

list是一种有序的集合,可以随时添加和和删除其中的元素

x = ['a','b']

列表的数据项不需要具有相同的类型
创建一个列表,只要把逗号分隔额数据项使用方括号括起来即可

列表可以进行截取,组合等

增

你可以对列表的数据进行修改或更新

• append()方法来添加列表项
• insert(位置,'更新的值')，把元素插入到指定的位置
• extend，在列表的末尾一次性追加另一个序列中的多个值

list1 = [1, 2, 3, 4, 5, 6, 7 ]
print(list1)
x = list1.insert(8,"next")
print(list1)

b = [1,2,3]
c = [4,5,6]
b.extend(b)
#把c的值,添加到b中,创建全新的列表
print(a)

删

• del语句来删除列表的的元素
• pop() 删除list末尾的元素,也可以删除指定位置的元素
• clear 清空
• remove("内容")

list1 = [1, 2, 3, 4, 5, 6, 7 ]
del list[2]

x  = [1,2,3,4,5,6]
print(x.pop())
print(x)
print(x.pop(0))
print(x)

改+查

• 使用下标索引来访问列表中的值,同样你也可以使用方括号的形式截取字符
• 切片去查，或者循环去查

list1 = ['Google', 'Runoob', 1997, 2000]
list2 = [1, 2, 3, 4, 5, 6, 7 ]

print("list1[0]:",list1[0]) #使用下标获取
print("list2[1:5]: ", list2[1:5]) #通过截取获得

##########################################

a = [1,2,3,4,5,6]

print(a[1:]) #从下标1取到最后
print(a[1:-1]) #取倒数第二值
print(a[1:-1:1]) #从左到右一个一个去取
print(a[1::2]) #从左到右隔一个去取
print(a[3::-1])

其他操作

• count，计算某元素出现的次数

a = [1,2,3,4,5,6,1,2,2,2,2,2,2].count(2)
print(a) #打印a中的2出现的次数

• index，用于从列表中找出某个值第一个匹配的索引位置

a = ['xiaoli','jinqi','xiaopan']
print(a.index('xiaopan'))

#返回列表中以下标出现的索引值

• sort，用于在原位置对列表进行排序
• reverse，将列表中的元素反向存放

a = [2,1,3,4,5]
a.sort()
# 他没有返回值，所以只能打印a
print(a) 
# [1, 2, 3, 4, 5]

###############################

a.reverse()
#他也没有返回值，所以只能打印a
print(a)
# [5, 4, 3, 1, 2]

• join()

用于将序列中的元素以指定的字符连接成一个新的字符串

a = 'abcde'
print('*'.join(a))

嵌套列表

即在列表里创建其他列表

a = [1,2,3,4,5,6]
b = [7,8,9]

x = [a,b]
print(x)

访问嵌套列表中的值

# 访问字符串中的某个字
li = ['asadasd','吴越','大浪']
print(li[2][1])

a = [1,2,3,4,5,6,[7,8,9]]
# 访问7
print(a[6][0])

列表操作符

• len() 获取长度
• + 组合
• * 重复
• in 元素是否存在于列表中
• for x in [1,2,3]:print(x,end="") 迭代

len([1,2,3])

name = [1,2,3]+[4,5,6]
x = ["HI"]*4

print(3 in [1,2,3])
print(x)
print(name)

---

0x12 字典（dict）

dict在其他语言中也称为map,使用键-值(key-value)存储,具有极快的查找速度

dict的key必须是不可变对象
这是因为dict根据key来计算value的存储位置,如果每次计算相同的key得出的结果结果不同
那dict内部就完全混乱了
通过key计算位置的算法称为哈希算法(Hash)

把数据放入dict的方法,除了初始化时指定外,还可以通过key放入

d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
d['admin']=67
print(d)

>> {'Michael': 95, 'Bob': 75, 'Tracy': 85, 'admin': 67}

tips：由于一个key只能对应一个value，所以，多次对一个key放入value，后面的值会把前面的值冲掉

判断key是否存在

tips： 如果key值不存在，dict就会报错，所以报避免key不存在的错误

• in判断key是否存在
• dict提供的get()方法，如果key不存在，可以返回None，或者自己指定的value

d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
print("rom" in d)

print(d.get('rom',"不存在"))

增

• setdefault(key,default=None)，如果键不存在与字典中，将会添加键并将值设为默认值

d = {'dict':'字典',}
d['hello'] = '你好'
print(d)

dict = {'runoob': '菜鸟教程', 'google': 'Google 搜索'}
print("Value : %s" % dict.setdefault('runoob', None)) #Value : 菜鸟教程
print("Value : %s" % dict.setdefault('Taobao', '淘宝')) #Value : 淘宝
print(dict)

# {'runoob': '菜鸟教程', 'google': 'Google 搜索', 'Taobao': '淘宝'}

删除元素

• 删除一个key,用pop(key)方法,对应的value也会从dict中删除
• clear清空字典
• popitem()随机删除字典中的某个键值对，将删除的键值对以元组的形式返回

d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
print(d.pop('Bob'))
print(d)

>> 75   {'Michael': 95, 'Tracy': 85}

tips:dict内部存放的顺序和key放入的顺序是没有关系的

改

update

# 将dict所有的键值对覆盖添加(相同的覆盖，没有的添加)到dic2中

dic = {"name":"jin","age":18,"sex":"male"}
dic2 = {"name":"alex","weight":75}
dic2.update(dic)
print(dic2)

查

dict = {'runoob': '菜鸟教程', 'google': 'Google 搜索'}
value = dict["google"]
print(value) #没有会报错

其他操作

• items()，返回可遍历的（键,值）元组数组

dict = {'Google': 'www.google.com', 'Runoob': 'www.runoob.com', 'taobao': 'www.taobao.com'}
print(dict.items())

for i in dict.items():
    print(i)

# ('Google', 'www.google.com')
# ('Runoob', 'www.runoob.com')
# ('taobao', 'www.taobao.com')

• values()以列表返回字典中的所有值

dict = {'Google': 'www.google.com', 'Runoob': 'www.runoob.com',}
print(dict.values())

# 返回 ==> dict_values(['www.google.com', 'www.runoob.com'])

• keys()以列表返回一个字典所有的键

dict = {'Name': 'Zara', 'Age': 7}

print "Value : %s" %  dict.keys()

字典的循环

dict = {'runoob': '菜鸟教程', 'google': 'Google 搜索'}

# 如果直接循环，默认是直接打印他的键
for i in dict:
    print(i)

# 用元组显示键值
for item in dict.items():
    print(item)

# 分别打印键和值
for key,value in dict.items():
    print(key,value)

字典的嵌套

dic = {
    'name':['alex','wusir','taibai'],
    'py9':{
        'time':'123',
        'learn_money':19800,
        'addr':'CBD',
    },
    'age':21
}

dcit的特点

• 查找和插入的速度极快,不会随着key的增加而变慢
• 需要占用大量的内存,内存浪费多

---

0x13 Set

集合是无须的，不重复的数据集合，它里面的元素是可哈希的（不可变类型），但是集合本身是不可哈希（所以集合做不了字典的键）的。

• 去重，把一个列表变成集合，就自动去重了
• 关系测试，测试两组数据之前的交集，差集，并集等关系

创建

parame = {value,value1,value2,.......}
或
set(value)

增

• add()，重复的元素在set中自动被过滤
• update()

set1 = {1,2,3,4,5,6,7,8,9}
set1.add(123)
set1.update(789)
print(set1)

删

• remove()，按元素删除
• clear()，清空集合
• del 删除整个集合
• pop()，随机删除

set1 = {1,2,3,4,5,6,7,8,9}
print(set1.pop())

set1.remove(7)
print(set1)

del set1

查

只能用for去查

set1 = {1,2,3,4,5,6,7,8,9}
for i in set1:
    print(i)

其他操作

• 交集，(& 或者 intersection)，就是两个集合中相同的

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 & set2)  # {4, 5}
print(set1.intersection(set2))  # {4, 5}

• 并集，（| 或者 union）,两个集合合并，相同的去掉

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 | set2)  # {1, 2, 3, 4, 5, 6, 7}

print(set2.union(set1))  # {1, 2, 3, 4, 5, 6, 7}

• 差集，（- 或者 difference），集合独有的

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 - set2)  # {1, 2, 3}
print(set1.difference(set2))  # {1, 2, 3}

• 反交集，（^ 或者 symmetric_difference），去掉相同的并返回

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 ^ set2)  # {1, 2, 3, 6, 7, 8}
print(set1.symmetric_difference(set2))  # {1, 2, 3, 6, 7, 8}

• 子集与超集

子集：一个集合包含另一个集合中的所有

set1 = {1,2,3}
set2 = {1,2,3,4,5,6}

print(set1 < set2)
print(set1.issubset(set2))  # 这两个相同，都是说明set1是set2子集。

print(set2 > set1)
print(set2.issuperset(set1))  # 这两个相同，都是说明set2是set1超集。

• frozenset不可变集合，让集合变成不可变类型

s = frozenset('barry')
print(s,type(s))  # frozenset({'a', 'y', 'b', 'r'}) <class 'frozenset'>

• 例子：列表去重

li = [1,1,1,1,1,2,2,2,2,3,4,5,49,9,1]
set1 = set(li)
li = list(set1)
print(li)

---