1. 基本数据类型
1）数字
（1）int类型
常用功能：
.__add__()
bit_length()获取可表示的二进制的最短位数
2）字符串，str类型，一次性创建，不能被修改，只要修改就需要再创建
常用方法：
a = 'bob'
（1）capitalize()，首字母大写
a.capitalize
（2）center，居中显示，第一个参数为位数，第二个参数为填充符号（默认为空格）
a.center(20,'*')
（3）count，字符串中某字符出现的次数，第一个参数指定查找的字符，第二个参数为查找起始位置，第三个参数为查找的终止位置
a.count('b',0,3)
（4）endswith，是否以某结尾，第一个参数指定查找的字符，第二个参数为查找起始位置，第三个参数为查找的终止位置
a.endswith('b')
（5）expandtabs，将tab转化成空格
a = 'hello\t999'
a.expandtabs()
（6）find，寻找子序列位置，如果没找到，返回-1
a.find('lo')
（7）format，字符串格式化，动态参数
"hello {0}, age {1}".format('Bob',19)
（8）index，子序列位置，如果没找到，报错
a = 'hello world'
a.index('w')
（9）isalnum，判断是否是字母和数字
a.isalnum('Abc')
（10）isalpha，判断是否是字母
a.isalpha()
（11）isdigit，判断是否是数字
a.isdigit()
（12）islower，判断是否小写
a.islower()
（13）isspace，判断是否空格
（14）isupper，判断是否大写
（15）istitle，判断是否标题
（16）join，连结
name_list=['Alex','Eric']
s = ' '.join(name_list)
（17）ljust，内容左对齐，右侧填充
（18）lower，变小写
（19）lstrip，移除左侧空白
（20）rstrip，移除右侧空白
（21）replace，替换
a.replace('a','El')
（22）rfind，从右向左找
（23）rindex，从右向左找
（24）rjust，内容右对齐，左侧填充
（25）split，分割，第二个参数可以指定最多分割几次
a.split('e')
（26）rstrip，移除右边空白
（27）startswith，是否以某开始
（28）strip，移除两段空白
（29）swapcase，大写变小写，小写变大写
（30）title，将字符串转换成标题
（31）upper，变为大写
（32）zfill，返回指定长度的字符串，原字符串右对齐，前面填充
（33）索引
a[2]
（34）切片
a[0:2]
（35）长度，len()
（36）字符 =》字节
bytes_list = bytes("字符串",encoding='utf-8')
print(bytes_list) #默认每个字节都是16进制表示
for b in bytes_list:
print(b) # 默认每个字节都是10进制表示
10进制的数字=》2进制
bin(10进制的数字)
3）列表，list
name_list = ['Steve','Bill','John']
（1）索引
name_list[0]
（2）切片
name_list[0:2]
（3）len长度
name_list[2:len(name_list)]
（4）for循环
for i in name_list:
print(i)
（5）append追加元素
name_list.append('Jobs')
（6）count统计某个元素出现的次数
name_list.count('Jobs')
（7）extend，扩展列表
name_list.extend(temp_list)
（8）index，获取某个值的索引
name_list.index('John')
（9）insert，在某个位置插入一个值
name_list.insert(1,'Nash')
（10）pop，拿到最后一个值并赋给新值
name_list.pop()
（11）remove，移除从左找到的第一个某元素
name_list.remove('Steve')
（12）reverse，将列表反转
name_list.reverse()
（13）sort，将列表排序
name_list.sort()
（14）del，删除某个索引下的元素
del name_list[1]
4）字典，dict，每个元素都是键值对
user_info = {'name':'Steve', ‘age’:25, ‘gender’:'M'}
（1）索引
user_info['name']
（2）循环
for i in user_info:
print(i)
（3）键值对
user_info.keys()
user_info.values()
user_info.items()
for key, val in user_info.items():
print(key + ":" + val)
（4）clear，清除所有内容
user_info.clear()
（5）get，根据key获取值，如果key不存在，可以制定一个默认值
user_info.get('nation','unknown')
（6）has_key，检查字典中指定key是否存在
user_info.has_key('age')
（7）pop，获取并在字典中移除
user_info.pop('age')
（8）setdefault，如果key不存在，则创建，如果存在，则返回已存在的值且不修改
user_info.setdefault('nation','UK')
（9）update，批量更新
test = {'language':'English','phone':'13123231441'}
user_info.update(test)
（10）del，删除
del user_info('phone')
（11）enumerate，自动生成键值对形式，key默认自增，从0开始
li = [‘CPU’,'Memory','Driver','Screen']
for key,item in enumerate(li):
print(key,item)
（12）range，指定范围，生成指定的数字，还可以指定步幅
for i in range(1,10,2):
print(i)
for i in range(10,1,-2):
print(i)
（13）fromkeys，从某个字典选某些keys，并指定value，生成一个新的字典
5）集合，不允许重复，可以用来去重
s = set()
（1）add，添加元素
s.add('Steve')
（2）difference，找前A中存在的，B中不存在的元素
s1 = (11,22,33)
s2 = (22,55,33)
s1_remain = s1.difference(s2) # 留下11
s2_remain = s2.difference(s1) # 留下55
（3）difference_update，从当前集合中删除和B中相同的元素
s1 = (11,22,33)
s2 = (22,55,33)
s1_remain = s1.difference_update(s2) # 留下11
（4）clear，清空
s.clear()
（5）discard，移除指定元素，不存在不报错
s.discard()
（6）remove，移除元素
s.remove('Steve)
（7）intersection，取交集
（8）intersection_update，取交集并更新到A中
（9）isdisjoint，如果没有交集，返回True，否则返回False
（10）issubset，是否是子序列
（11）issuperset，是否是父序列
（12）pop，移除元素，并返回该元素
（13）symmetric_difference，取并集
（14）symmetric_difference_update，取并集并更新
2. 三元运算（又名三目运算）
name = 值1 if 条件 else 值2
name = 'Steve' if 1 == 1 else 'Bill'
3. 深浅拷贝，数字和字符串不管怎么拷贝都是同一份
import copy
n1 = 123
1）浅拷贝，只拷贝了外面的一层，指向你n1的内存地址空间
n2 = copy.copy(n1)
2）深拷贝，除了最后一层都拷贝
n3 = copy.deepcopy(n1)
4. 函数式编程
1）定义函数
def 函数名(形式参数):
函数体
return 值
2）return返回值
注意：函数在执行过程中只要遇到return语句，就会停止执行并返回结果；如果未在函数中指定return，那这个函数的返回值为None
例，发送邮件的函数：
def email():
flag = True
try:
import smtplib
from email.mime.text import MIMEText
from email.utils import formataddr
msg = MIMEText('Email Message','plain','utf-8')
msg['From'] = formataddr([‘Steve’,'[email protected]'])
msg['To'] = formataddr(['Bill','[email protected]'])
msg['subject'] = 'Test Email'
server = smtplib.SMTP(''smtp.126.com",25)
server.login('[email protected]','123456')
server.sendmail('[email protected]',['[email protected]',], msg.as_string())
server.quit()
except:
flag = False
return flag3）嵌套函数
def fun1():
print('alex')
def func2():
print('eric')（1）函数内部可以再次定义函数
（2）执行需要被调用
4）匿名函数
def calc(x,y):
return x * y
func = lambda x,y: x*y # 声明一个匿名函数
print(func(3,5))print(list(map(lambda x: x*x, list(range(10)))))
特点：
（1）节省代码量
（2）看起来高大上
5）高阶函数
只要满足以下任意一个条件，即是高阶函数
（1）接受一个或多个函数作为输入
（2）return返回另外一个函数
5. 参数
1）形参，实参（默认，按照顺序）
指定形参传入实参，可以不按照顺序
2）默认参数（有默认值的参数一定要放在所有参数的尾部）
def enroll(name, age, nationality='China')
3）关键参数，指定了参数名的参数就叫关键参数，但关键参数必须放在位置参数之后
def enroll(name, age, nationality='China')
stu_1 = enroll('Alex', nationality='USA, age = 22)
4）动态参数，非固定参数
(1) *args，将参数变为元组
def f(*args):
(2)**kwargs，将参数转换为字典
def f(**kwargs):
def fun(name, *args, **kwargs)
func("Steve", "tt", "Lebron", addr="Beijing", age="24")
6. 变量，可以通过global指定某变量为全局变量
1）全局变量，定义在函数外部的一级代码。全局变量全局能用。默认全局变量全用大写
在函数里面修改全局变量：
name = 'a'
def change_name():
global name
name = b
print(name)
print(name)2）局部变量，定义在函数里的变量。只在局部生效。默认局部变量全用小写。在函数内部，可以应用全局变量。如果全局和局部都有一个变量为data，函数查找变量的顺序为从内而外。
7. lambda表达式
lam = lambda a1, a2: a1 + a2
8. Python内置函数
1）abs，绝对值
n = abs(-12300)
2）all，循环参数，如果每个元素都为真，那么all的返回值为真，有一个为假则为假
r = all([True,True,False])
False
3）bool，0、None、空值都为假，其他为真，把一个对象转换成布尔值
4）any，只有一个为真，则为真
5）ascii，对象的类中找__repr__，获取其返回值
ascii(对象)
6）bin，二进制
7）oct，八进制
8）int，十进制
9）hex，十六进制
10）二进制转换为十进制
num = int('0b11', base = 2)
11）八进制转换为十进制
num = int('0o11', base = 8)
12）十六进制转换为十进制
num = int('0xe', base = 16)
13）bytes，字节
14）bytearray，字节列表
15）字符串转换为字节
bytes("xxx", encoding="utf-8")
16）callable，查看对象是否可以执行
def func1():
return
r = callable(func1)
print r
17）compile，编译
code = '''def hellocute() return 123 '''
func = compile(code, "<string>", "exec")
18）eval，转化为数值，有返回值，只能处理单行代码
ret = eval("1 + 3")
print ret
19）exec，执行字符串形式的python代码
exec("for i in range(10): print(i)")
20）filter，循环可以迭代的对象，获取每一个参数，函数（参数）
filter(函数，可以迭代的对象)
def func1(x):
if x > 10:
return True
else:
return False
ret = filter(func1, [8, 12, 7, 66, 45, 6, 92])
for i in ret:
print i
21）map，
map(函数，可以迭代的对象)
def func(x):
return x + 1
list1 = [1,2,3,4,5]
res = map(func, list1)
22）frozenset，不可变得集合
23）globals，获取当前代码中所有全局变量
23）locals，获取所有局部变量
24）hash，生成哈希值，一般用来作字典key的优化
25）id，查看对象内存地址
26）input，输入
27）isinstance，判断是否是某个类的对象
li = [11,2]
r = isinstance(li, list)
28）max，获取列表、集合等中的最大值
29）min，获取列表、集合等中的最小值
30）pow，求指数
i = pow(2, 10)
31）round，四舍五入
n = round(3.3)
31）open，文件操作
open(文件名，模式，编码)
打开文件的模式有：
r：只读模式【默认】
w：只写模式【不可读；不存在则创建；存在则清空内容】
x：只写模式【不可读；不存在则创建，存在则报错】
a：追加模式【不可读；不存在则创建；存在则只追加内容】
“+”表示可以同时读写某个文件
r+：读写【可读，可写】
w+：写读【可读，可写】
file = open('hadoop.log')
data = file.read()
file.close()
print data
字节文件的读写，python3中的方法，以b方式打开时，读取到的内容是字节类型，写入时也需要提供字节类型
rb或r+b：只读，python内部将二进制编码转换成了字符串
file = open('hadoop.log', 'rb')
data = file.read()
file.close()
print(data)
wb或w+b：只写
file = open('hadoop.log', 'rb')
file.write(bytes("Hello World"), encoding='utf-8')
xb或x+b：
ab或a+b：
指针：
file = oepn("hadoop.log", "r+")
print(file.tell()) # file.tell() 当前指针的位置，刚打开文件指针为起始位置0，
data = file.read()
file.write("I love Python")
file.seek(0) # file.seek() 指定指针的位置
data = file.read(3) # file.read(3)指定指针的读取位置
# w，末尾追加，指针移动到最后
# w+，先清空，再写的时候，就可以读了，先清空，之后写的才能读写，指针到最后
file = open("hadoop.log", "w+", encoding="utf-8")
file.write("Steve")
file.seek(0)
data = file.read()
file.close()
print(data)
# x+如果文件存在，则报错
#a+追加内容，文件打开的同时，指针已经到最后了；写时，追加，指针也会放到最后
file = open("hadoop.log", "a+", encoding="utf-8")
data = file.read()
file.seek(0)
file.close()
file.tell() # 获取指针的位置
file.seek(num) # 调整指针的位置
32）sum，求和
33）type，查看对象类型
34）zip，将两个组合起来
li1 = [1,2,3,4]
li2 = ['a','b','c','d']
r = zip(li1, li2)
for i in r:
print i
35）sort，排序，元素必须是同一种类型
36）print
print(s, end='|', sequence='->')
37）locals，局部变量
38）
内置函数实例：生成一个随机数，65-90，数字转化正字母，chr(数字)
import random
i = random.randrange(65,91)
c = chr(i)
print c
内置函数实例：随机生成字符串
import random
temp = ""
for i in range(0,6):
num = random.randrange(4)
if num == 3 or num == 1:
rand1 = random.randrange(0,10)
temp += str(rand1)
else:
rand2 = random.randrange(65,91)
c = chr(rand2)
temp += c
print temp
9. 文件处理
f = open('data.txt', 'r', encoding='utf-8')
data = f.read()
f.close()1）对文件的处理模式
'r'，只读，字符。读完一遍内容后，光标会移到最后
'rb'，只读，二进制
'w', 只写，字符
'wb'，只写，二进制
'a', 追加
'r+', 读写混合
'w+', 写读混合，先创建文件，原来的文件内容先被重写
2）如果不知道文件的编码方式，chardet可以智能检测：
import chardet
result = chardet.detect(open('log', 'rb').read())
print(result)3）循环文件
f = open('data.txt', 'r')
lines = f.read()
for line in lines:
print(line)4）对文件内容操作的api
（1）close，关闭文件
（2）fileno，文件描述符
（3）flush，刷新文件内部的缓冲区，把文件从内存强指刷新至硬盘
（4）read，读取指定字节数据
（5）readable，是否可读
（6）readline，仅读取一行数据
（7）seek，指定文件中指针位置
（8）seekable，指针是否可操作
（9）tell，获取指针位置
（10）truncate，截断数据，仅保留指定之前的数据
（11）write，写内容
10. 上下文管理，自动关闭文件，且可以同时打开两个文件
with open("hadoop1.log", 'r') as file1, open("hadoop2.log", "r") as file2:
pass
with open("hadoop1.log", "r") as file1, open("new_hadoop.log", "w") as file2:
pass
11. 递归
递归函数：
def factorial(n):
if n == 1:
return 1
return n * factorial(n - 1)
print(factorial(10))
尾递归优化：
def cal(n):
print(n)
return cal(n + 1)
cal(1)12. 命名空间，名称空间
名称空间正是存放名字x与1绑定关系的地方
1）名称空间共3种：
（1）locals：是函数内的名称空间，包括局部变量和形参
（2）globals：全局变量，函数定义所在模块的名字空间
（3）builtins：内置模块的名字空间
不同变量的作用域不同就是由这个变量所在的命名空间决定的
2）作用域即范围
（1）全局范围：全局存活，全局有效
（2）局部范围：临时存活，局部有效
3）作用域的查找范围
locals-》enclosing function-》globals-》__builtins__
locals是函数内的名字空间，包括局部变量和形参
enclosing外部嵌套函数的名字空间
globals全局变量，函数定义所在模块的名字空间
builtins内置模块的名字空间
13. 闭包
代码示例：
def func():
n = 10
def func2():
print("funky:", n)
return func2
f = func()
print(f)
f()