1.python中条件判断语句：if-elif-else

**python中没有：switch..case语句

a,b=7,-1print('----------------------')while a!=b:    x = int(input("请输入一个数字："))    if x == a:        print('输入正确！')    elif x > a:        print('太大！')    elif x < a:        print('太小！')

2.for循环、while循环

①for循环

#for循环常用于遍历序列#结合range()+len()遍历序列的索引x=["a","b","c","d"]for i in range(len(x)):    print(i,x[i])>>>0 a1 b2 c3 d@for中嵌套iffor i in range(2,10):    for x in range(2,i):        if i % x == 0:            print(i,'等于',x,'*',i//x)            break    else:        #循环中没有找到元素        print(i,'是质数')>>>2 是质数3 是质数4 等于 2 * 25 是质数6 等于 2 * 37 是质数8 等于 2 * 49 等于 3 * 3@for循环使用'else'、'break'、'continue'sites = ["Baidu", "Google","Runoob","Taobao","JD","yahu","tenxun"]for i in sites:    if i == "Google":        print("跳过循环")        continue    elif i == "JD":        print('停止循环！')        break    print("循环的数据：" + i)else:    print("没有循环的数据！")print("完成循环")

②while循环

**python中没有do..while()循环

#while循环n,sum,count = 100,0,1while count <= n:    sum = sum + count    count += 1print('1到%d的和为：%d' % (n,sum))>>>1到100的和为：5050@while循环中'else'的使用，在语句为false时执行else语句count = 0while count < 5:    print(count,'< 5')    count = count + 1else:    print(count,'>= 5')>>>0 < 51 < 52 < 53 < 54 < 55 >= 5@break和continue语句i = 10while i > 0:    i = i - 1    if i == 5:        continue    elif i == 3:        break    print('输出：%s' % i)print('GODD BYE !')

3.列表、元组、字典、集合

①列表

#1.列表 list=[0,1,2,3,4]  @截取：下标，print(list[2:])@更新：下标，list[2]=9@删除：下标，del list[2]@长度：print(len(list))@集合拼接：list+list2; list+=[2,3,4,4,5,6] print(list)@函数：#len(list) 列表长度#max(list) 返回列表元素最大值#min(list)  返回列表元素最小值#list(seq) 将元组转换为列表#for x in [1, 2, 3]: print(x, end=" ") 迭代输出@方法：①.list.addend(5) 在列表末尾追加5 x = [1,2,3,2,2,2,]x.append(5)print(x)在末端添加多个元素：breakfast.extend(["juice","decaf","tom","tea","egg"])print(breakfast)②.list.count(4) 统计4元素在列表出现的次数x = [1,2,3,2,2,2,]s=x.count(2)print(s)>>>4③.list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）x = [1,2,3,2,2,2,]x.extend([3,4,5])print(x)>>>[1, 2, 3, 2, 2, 2, 3, 4, 5]④.list.index(obj) 从列表中找出某个值第一个匹配到的索引位置x = [1,2,3,2,2,2,]s=x.index(3)print('对应的下标位置：',s)>>>对应的下标位置： 2⑤.list.insert(index,obj) 根据下标增加元素**如果指定的下标有元素，insert作为更新使用x = [1,2,3,4,5,6]x.insert(4,7)print(x)>>>[1,2,3,4,7,6]⑥.list.pop() 随机删除列表中的元素并返回该元素，默认是最后一个x = [1,2,3,4,5,6]s=x.pop()print(s)>>>6⑦.list.remove() 指定删除列表元素x = [1,2,3,4,5,6]x.remove(4)print(x)>>>[1,2,3,5,6]⑧.list.reverse()  反转列表中的元素x = [1,2,3,4,5,6]x.reverse()print(x)>>>[6, 5, 4, 3, 2, 1]⑨.list.sort() 对原列表进行排序x = [1,6,7,3,2,5]x.sort()print(x)>>>[1, 2, 3, 5, 6, 7]⑩.list.clear()  清空列表x = [1,2,3,2,2,2,]x.clear()print(x)>>>[]十一.list,.copy()  复制列表x = [1,6,7,3,2,5]s= x.copy()s+=[11,9]print(s)>>>[1, 6, 7, 3, 2, 5, 11, 9]

**列表中常用的数据结构方法***

#①嵌套列表解析:将3x4的矩阵列表转换为4x3列表matrix = [1,2,3,4],[5,6,7,8],[9,10,11,12]transposed = []for i in range(4):    transposed.append([row[i] for row in matrix])print(transposed )>>>[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]#以上方法等同于：x = [[row[i] for row in matrix] for i in range(4)]print(x)>>>[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]#②o = [2,4,6]s=[[i,i*3] for i in o]print(s)>>>[[2, 6], [4, 12], [6, 18]]#③o = [2,4,6]x = [3*i for i in o if i>3]print(x)>>>[12, 18]#④v1 = [1,2,3,4]v2 = [5,6,7,8]s = [x*y for x in v1 for y in v2]print(s)>>>[5, 6, 7, 8, 10, 12, 14, 16, 15, 18, 21, 24, 20, 24, 28, 32]l = [v1[i]*v2[i] for i in range(len(v1))]print(l)>>>[5, 12, 21, 32]

②元组

#2.tup=() #元组中的元素不允许修改，可截取，拼接@创建：tup=(50,)（元组中只包含一个元素时，需要在元素最后添加逗号，否则括号会被当作运算符来使用）@截取：下标，print(tulp[1])@拼接：tup3=t1+t2@删除：del tup（元组中的元素不允许删除，正能删除整个元组）@迭代：for x in (1,2,3):                   print(x,end=' ')>>>123#函数①.len(tuple)  计算元组的元素个数tup=(1,2,3,4)print(len(tup))>>>4②.max(tuple) 返回元组中元素最大值③min(tuple) 返回元组中元素最小值④.tuple(seq)  将列表转换为元组x=[0,2,3,4]print(tuple(x))>>>(0, 2, 3, 4)

③字典

#dict={key1:value1,key2:value2}，key值唯一不可变，value可#字典键的特性：字典值-可以是任何python对象，既可以是标准对象，也可以是用户自定义；键是唯一不可变的，如果相同的字典中出现了相同的键，那么相同的键只会输出最后一次赋的值，键不可用列表@创建：dict = {
    'abc':456,5:9}@访问：通过键，print(dict['abc'])@更新：通过键，dict['abc'] = 8@添加：键值对，dict['School'] = "测试添加"@删除：del dict['abc'] 删除键  del.clear() 清空字典   del dict 删除字典#函数①.len(dict) 字典的键值对个数dict = {
    'abc':123,'tom':3,5:7}print(len(dict))>>>3②str(dict) 输出字典dict = {
    'abc':123,'tom':4,'jon'"7}print(str(dict))>>>{
    'abc':123,'tom':4,'jon'"7}#方法①dict.clear()  删除字典内所有元素x = {
    'abc':123,4:5,7:8}x.clear()print(x)>>>{}②dict.copy()  浅拷贝一个字段#dict1=dict.copy() 浅拷贝：深拷贝父对象（一级目录），子对象（二级目录）不拷贝，还是引用；#dict1 = dict   浅拷贝: 引用对象 x = {
    'abc':123,4:5,7:8}s = x.copy()print(s)>>>{
    'abc':123,4:5,7:8}③dict.fromkeys(seq) 创建一个新的字典#将列表转换为字典seq=('name','age','sex')dict = dict.fromkeys(seq)  #返回空值的键print("新的字典：%s" %  str(dict))>>>新的字典：{
    'name': None, 'age': None, 'sex': None}****seq=('name','age','sex')dict = dict.fromkeys(seq,10)  #返回赋值的键s=dict['name']='tom'   #更新值print("新的字典：%s" %  str(dict))print('新的dict：'dict) #赋值返回新的dict>>>新的字典：{
    'name': 'tom', 'age': 10, 'sex': 10}④dict.get(key)  返回指定键的值dict = {
    'key1': 2, 'key2': None, 'key3': None}print(dict.get('key1'))>>>2⑤key in dict 判断键是否在dict中⑥dict.items() 以列表返回可遍历的（键，值）元组数组dict = {
    'key1': 2, 'key2': 4, 'key3': 5}print(dict.items())>>>dict_items([('key1', 2), ('key2', 4), ('key3', 5)])⑦dict.keys() 返回一个迭代器，可以用你list()来转换为列表dict = {
    'key1': 2, 'key2': 4, 'key3': 5}print(list(dict.keys()))>>>['key1', 'key2', 'key3']  #只返回键⑧dict.setdefault(key,defualt=None) 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为defaultdict = {
    'key1': 2, 'key2': 4, 'key3': 5}print('查询的键：%s' % dict.setdefault('key4')) #查找的键print('返回新的字典：%s' % dict)  #返回新添加的键值对>>>查询的键：None>>>返回新的字典：{
    'key1': 2, 'key2': 4, 'key3': 5, 'key4': None}⑨dict.update(dict2) 把字典dict2的键值对更新到dict中dict = {
    'key1': 2, 'key2': 4, 'key3': 5}dict2 = {
    'key6': 7,}dict.update(dict2)print(dict)>>>{
    'key1': 2, 'key2': 4, 'key3': 5, 'key6': 7}⑩dict.values()  返回一个迭代器，可以用list()来转换为列表dict = {
    'key1': 2, 'key2': 4, 'key3': 5}print(list(dict.values())) >>>[2, 4, 5] #同keys相反，values()只取返回值⑾dict.pop(key)  删除字典给定的键key所对应的值并返回dict = {
    'key1': 2, 'key2': 4, 'key3': 5}print(dict.pop('key1'))print(dict)>>>2>>>{
    'key2': 4, 'key3': 5}⑿dict.popitem()  随机删除字典中的一对和值（一般删除最后一对）dict = {
    'key1': 2, 'key2': 4, 'ksey3': 5}print(dict.popitem())print(dict)>>>('ksey3', 5)>>>{
    'key1': 2, 'key2': 4}

④集合

#集合 set={value} 或 set=(value)，创建空的集合：set=() ，{} 为创建空的字典#集合是一个无序的不重复的元素序列@创建：set(value)@去重：a = {
    'name','age','sex','sex','name','age'}  print(a)>>>{
    'name','age','sex'}@运算：①集合a内包含不包含集合b的元素：a-ba={
    'abcdef'}b={
    'abrt'}print(a-b)>>>{
    'abcdef'}②集合a或b中包含的所有元素：a|ba={
    'abcdef'}b={
    'abrt'}print(a|b)>>>{
    'abcdef', 'abrt'}③集合a和b都包含的元素：a&ba={
    'abcdef','tom'}b={
    'abrt','tom'}print(a&b)>>>{
    'tom'}④不同时包含于a和b的元素：a^ba={
    'abcdef','tom'}b={
    'abrt','tom'}print(a^b)>>>{
    'abrt', 'abcdef'}#方法①add()  为集合添加元素a={
    'abcdef','tom'}a.add('jir')a.add('erer')print(a)>>>{
    'jir', 'tom', 'abcdef', 'erer'}②clear()  移除集合中的所有元素b={
    'abrt','tom'}b.clear()print(b)>>>set()③copy()  拷贝一个集合b={
    'abrt','tom'}x=b.copy()print(x)>>>{
    'abrt', 'tom'}④difference()  返回多个集合的差集，返回一个新的set()x = {
    "apple", "banana", "cherry"}y = {
    "google", "microsoft", "apple"}z = x.difference(y)       #以X作为参数,y进行匹配print(z)>>>{
    'banana', 'cherry'}⑤set.difference_update() 在原来的集合上移除重复的数据，不反回新的set()x = {
    "apple", "banana", "cherry"}y = {
    "google", "microsoft", "apple"}x.difference(y)       #以X作为参数,y进行匹配,最后结果返回xprint(x)>>>{
    'banana', 'cherry'}⑥set.discard(value)  删除集合中指定的元素a = {
    "apple", "banana", "cherry"}a.discard('apple')print(a)>>> {
    'cherry', 'banana'}⑦set.intersection()  返回集合的交集a = {
    "apple", "banana", "cherry"}b = {
    "apple", "banana","erer","ertrt"}s=a.intersection(b)print(s)>>>{
    'apple', 'banana'}⑧set.intersection_update()  删除集合中的元素，该元素在指定的集合中不存在x = {
    "apple", "banana", "cherry"}y = {
    "google", "runoob", "apple"}x.intersection_update(y)print(x)>>>{
    'apple'}⑨set.isdisjoint() 判断两个集合是否包含相同的元素,ture/false#判断集合 y 中是否有包含 集合 x 的元素x = {
    "apple", "banana", "cherry"}y = {
    "google", "runoob", "facebook"}z = x.isdisjoint(y)print(z)  #不包含返回true,反之false>>>true⑩set.issubset()  判断指定集合是否为改方法参数集合的子集#判断集合 x 的所有元素是否都包含在集合 y 中x = {
    "a", "b", "c"}y = {
    "f", "e", "d", "c", "b", "a"}z = x.issubset(y)print(z)  >>>true   #集合y中包含了a集合的所有元素⑾set.issuperset()  判断该方法的参数集合是否为指定集合的子集#判断集合 y 的所有元素是否都包含在集合 x 中x = {
    "f", "e", "d", "c", "b", "a"}y = {
    "a", "b", "c"}z = x.issuperset(y)print(z)>>>true  #a集合包含了y集合的所有元素⑿set.pop()  随机删除集合中的元素并返回删除的元素x = {
    "apple", "banana", "cherry"}print(x.pop())>>>⒀set.remove()  移除指定集合中的元素x = {
    "apple", "banana", "cherry"}x.remove('apple')print(x)>>>{
    'cherry', 'banana'}⒁set.symmetric_difference()  返回两个集合中不重复的元素集合x = {
    "apple", "banana", "cherry","tom"}y = {
    "google", "runoob", "apple","tom"}z = x.symmetric_difference(y)print(z)>>>{
    'runoob', 'google', 'banana', 'cherry'}⒂set.symmetric_difference_update()  将两个集合合并并删除重复的值#在原始集合 x 中移除与 y 集合中的重复元素，并将不重复的元素插入到集合 x 中x = {
    "apple", "banana", "cherry"}y = {
    "google", "runoob", "apple"}x.symmetric_difference_update(y)print(x)>>>{
    'runoob', 'cherry', 'google', 'banana'}⒃set.union()  返回两个集合的并集#将两个集合合并并过滤掉忽略重复的元素x = {
    "apple", "banana", "cherry"}y = {
    "google", "runoob", "apple"}z = x.union(y)print(z)>>>{
    'cherry', 'runoob', 'google', 'apple', 'banana'}⒄set.update() 给集合添加元素#添加元素：x = {
    "apple", "banana", "cherry"}y = {
    "google", "runoob", "apple"}x.update({
     "tom"})print(x)>>>{
    'tom', 'cherry', 'apple', 'banana'}#添加集合元素：组合两个集合并忽略重复的元素x = {
    "apple", "banana", "cherry"}y = {
    "google", "runoob", "apple"}x.update(y)print(x)>>>{
    'google', 'banana', 'runoob', 'cherry', 'apple'}

 4.迭代器与生成器

@迭代器  可创建的对象；字符串、列表、元组@基本方法：iter()和next()@创建：x = [1,2,3,4,5]s = iter(x)>>>print(next(s))   #next()方法逐个打印>>>print(next(s))@for循环进行遍历打印：x = [1,2,3,4,5]s = iter(x)for i in s:    print(i,end=' ')>>>1 2 3 4 5 @next()方法循环输出：import sysx = [1,2,3,4,5]it = iter(x)while True:    try:        print(next(it),end=' ')    except StopIteration:        sys.exit()>>>1 2 3 4 5 #生成器 ：yield函数   生成器=迭代器import sysdef yield_new(n): #生成器函数 - 斐波那契    a,b,c = 0,1,0    while True:        if c > n:            return        yield a        a,b = b,a + b        c += 1s = yield_new(10)     # s 迭代器 由生成器返回生成while True:    try:        print(next(s),end=" ")    except StopIteration:        sys.exit()

5.函数

①默认参数

def printinfo(name,age=18):    print("姓名：%s" % name,end = ' ')    print("年龄：%s" % age)    returnprintinfo(name="tom",age=40)printinfo(name="root")>>>姓名：tom 年龄：40姓名：root 年龄：18

②不定长参数：加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。

#①不定长参数，声明时不会命名，语法：def functionname([formal_args,] *var_args_tuple ):      "函数_文档字符串"       function_suite       return [expression]#②*号参数def printinfo(arg1,*vartuple ):    '打印传入的任何参数'    print("输出：")    print(arg1)    print(vartuple)printinfo(70,80,60,50,"tom")>>>输出：70(80, 60, 50, 'tom')

 ③两个**基本语法：

#语法：def functionname([forname_args,] **var_args_dict ):      "函数_文档字符串"       function_siuite       return [expression]#加了两个**的参数会以字典的形式导入def printinfo(arg1, **vardict ):    print('输出：')    print(arg1)    print(vardict)printinfo(1,a=2,b=3)>>>输出：1{
     'a': 2, 'b': 3}# *在参数中单独出现def f(a,b,*,c):   return a+b+c@*号单独出现，*后面的参数必须用关键字传入def f(a,b,*,c):    print(a+b+c)    returnf(1,2,c=3)>>>6

 ④.匿名函数

#匿名函数：lambda[arg1 [,arg2,........argn]]:expressionsum = lambda arg1,arg2:arg1+arg2print('sum：',sum(10,20))>>>sum： 30

 6.变量作用域

①作用域

# L(local)  局部作用域、E(Enclosing)  闭包函数外、G(Global) 全局作用域、B(Built-in) 内置作用域(内置函数所在模块的范围)#查找规则：L->E->G->Bx = 0 #全局变量def login():     x = 1 #闭包函数外的函数中     def  inlog():            x = 2 # 局部作用域# 内置作用域：引入buitinimport builtinsprint(dir(builtins))

②global 和 nonlocal关键字

#规则：内部作用域想修改外部作用域的变量时@global 关键字修改无嵌套的变量num = 1def self_f():    global num # 修改num的值    print(num)        num = 123    print(num)self_f()>>>1>>>123@nonlocal 关键字修改嵌套作用域中的变量def out():    num = 10    def inner():        nonlocal num        num = 20    print(num)  #打印全局变量num    inner()    print(num) # 调用inner()方法 ，修改num值out()>>>10>>>20@调用全局变量作为参数是需要指定参数a = 10 def test(a):   #不指定变量a报错    a = a + 1    print(a)test(a)>>> 11

7.遍历的技巧

#遍历字典：关键字和对应的值可以使用items()方法解读出来k = {
    'gallahad': 'the pure', 'robin': 'the brave'}for k, v in k.items():    print(k, v)>>>gallahad the pure>>>robin the brave#遍历序列：索引位置和对应值可以使用enumerate()函数同时解读t = ['tom','gool','rengd','red']for i, v in enumerate(t):    print(i,v)>>>0 tom1 gool2 rengd3 red@遍历两个+的序列：使用zip()组合a = ['name', 'quest', 'favorite color']b = ['lancelot', 'the holy grail', 'blue']for i, v in zip(a,b):    print(i,v)>>>name lancelotquest the holy grailfavorite color blue@反向遍历序列：reversed()函数for i in reversed(range(1,10)):    print(i,end=' ')>>>9 8 7 6 5 4 3 2 1 @按顺序遍历一个序列：sorted()函数k = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']for i in sorted(set(k)):    print(i,end=' ')>>>apple banana orange pear

8.装饰器

9.输入输出

#输出格式化@format()和%:import mathprint('常亮PI的值近似为：{:.3f}'.format(math.pi))print('常亮PI的值近似为：%s' % math.pi)print('常亮PI的值近似为：%5.3f' % math.pi)>>>常亮PI的值近似为：3.142>>>常亮PI的值近似为：3.141592653589793>>>常亮PI的值近似为：3.142@表达式和print()函数@将输出的值转换为字符串：可以使用str()和repr()函数①str()  ：函数返回一个用户易读的表达式。②repr()：产生一个解释器易读的表达式。(repr()函数可以转移字符串中的特殊字符，参数可以是python的任何对象)s = 'howll \n'print(repr(s))print(str(s))>>>'howll \n'>>>howll x = 10 * 3.25y = 200 * 200s = 'x 的值为： ' + repr(x) + ',  y 的值为：' + repr(y) + '...'print(s)>>>x 的值为： 32.5,  y 的值为：40000...#输出平方与立方for x in range(1,11):    print(repr(x).rjust(2),repr(x*x).rjust(3),repr(x*x*x).rjust(4))>>> 1   1    1 2   4    8 3   9   27 4  16   64 5  25  125 6  36  216 7  49  343 8  64  512 9  81  72910 100 1000@rjust：将字符串靠右, 并在左边填充空格@ ljust() 和 center()：不写入任何数据，只返回新的字符串@zfill()：在数字的左边填充0（字符串）i = '11'print(i.zfill(3))>>>011#输出平方与立方等同于for x in range(1,11):    print('{0:2d},{1:3d},{2:4d}'.format(x,x*x,x*x*x))#{0:2d} 表示第一个参数x的格式。0 代表x,:2d 表示两个宽度的10进制数显示。#{1:3d} 表示第一个参数x*x的格式。1 代表x*x,:3d 表示三个宽度的10进制数显示。 #{2:4d} 表示第一个参数x*x*x的格式。2代表x*x*x,:4d 表示四个宽度的10进制数显示。#':'  ：在':'后传入一个整数，可以保证该域至少有这么多的宽度。用于美化表格时很有用table = {
    'google':1,'runoob':2,'taobao':3}for name,number in table.items():    print('{0:10} ==> {1:10d}'.format(name,number))  # : 后传入一个整数#格式化：最简单的就是传入一个字典, 然后使用方括号 '[]' 来访问键值table = {
    'google':1,'runoob':2,'taobao':3}print('google:{0[google]:d},runoob:{0[runoob]:d},taobao:{0[taobao]:d}'.format(table))>>>google:1,runoob:2,taobao:3@实现以上方法：**table = {
    'google':1,'runoob':2,'taobao':3}print('google:{google:d},runoob:{runoob:d},taobao:{taobao:d}'.format(**table))>>>google:1,runoob:2,taobao:3

10.斐波那契(fibonacci)

def fib(n):    # 定义到 n 的斐波那契数列    a, b = 0, 1    while b < n:        print(b, end=' ')        a, b = b, a+b    print()fib(1000)if __name__ == '__main__':    fib(100)

11.Python File

# r ：打开文件，只读方式import oswith open("Test.txt","r") as f:    for line in f:        print(line)    f.close()#r + ：打开一个文件用于读写，指针默认文件开头#rb+ ：以二进制格式打开一个文件用于读写，指针放到文件开头#w :打开一个文件进行写入内容，不存在则创建新文件，并从头开始进行重新编辑（即原有内容会被删除）#w+ ：打开一个文件用于读写，不存在则创建新文件，并从头开始进行重新编辑（即原有内容会被删除）#a ：打开一个文件用于追加内容，文件指针在末尾，不存在则创建#a+：打开一个文件用于读写内容，存在文件打开时为追加模式，文件指针在末尾，不存在则创建import osdef rfile(scr):    with open(scr,'r') as f:        for line in f:            print(line)        f.close()    returndef wfile(scr):    with open(scr,'a+') as f:        f.write('测试循环追加写入')        f.close()    returnif __name__=='__main__':    scr='Test.txt'    wfile(scr)    rfile(scr)

①指针：seek()函数

# f.seek()：改变指针在当前文件中的位置，可以使用f.seek(offset,from_what)函数#from_what 的值, 如果是 0 表示开头, 如果是 1 表示当前位置, 2 表示文件的结尾，例如：#seek(x,0) ： 从起始位置即文件首行首字符开始移动 x 个字符#seek(x,1) ： 表示从当前位置往后移动x个字符#seek(-x,2)：表示从文件的结尾往前移动x个字符import oswith open('Test.txt','r') as s:    print(s.read())    s.seek(0)        # 将指针移到文件开头重新打印    print(s.read())    s.close()#tell()函数：统计整个文件中的字符数import oswith open('Test.txt','r') as s:    print(s.read())    print(s.tell())    s.close()

②pickle 模块：数据序列和反序列化

# 基本接口：能对file以读取的形式打开x = pickle.load(file)pickle.dump(obj, file, [,protocol])# 使用pickle模块将数据对象保存到文件import pickledata1 = {
    'a': [1, 2.0, 3, 4+6j],         'b': ('string', u'Unicode string'),         'c': None}selfred_list = [1,2,3]selfred_list.append(selfred_list)output = open('data.pkl','wb')  #.pkl 二进制存储格式pickle.dump(data1,output)pickle.dump(data1,output,-1)print(output)output.close()#使用pickle模块从文件中重构python对象import pprint,picklepkl_file = open('data.pkl', 'rb')  data1 = pickle.load(pkl_file)pprint.pprint(data1)                #pprint模块：打印data.pklpkl_file.close()

③.方法

# 语法：open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)@file：必须，文件路劲@mode：可选，文件打开方式@buffering：设置缓冲@encoding：格式，一般使用utf8@errors：报错级别@newline：区分换行符@closefd：传入的file参数类型# 方法：①file.open(scr,mode)：打开文件②file.close()：关闭文件，打开文件操作后都需要执行close()方法进行关闭以释放资源③file.flush()：刷新文件内部缓冲，将缓冲的数据立刻写入文件names=['tom','Jerry','mike']names=[name + '\n' for name in names]          #推倒表达式 返回一个list+\nf=open('Test.txt','w',encoding='utf8')f.writelines(names)f.flush()     #不关闭文件情况下 将缓存在内存中的数据映射到硬盘文本中print(names)f.close()④file.fileon()：返回一个整型的文件描述符(file descriptor FD 整型), 可以用在如os模块的read方法等一些底层操作上⑤file.isatty()：文件链接到一个终端设备返回true，反之false⑥file.next()：返回文件下一行⑦file.rend([size])：读取文件指定的字节数，未给值或者给到负数则读取所有⑧file.readline()：默认读取第一行，包括\n字符f = open('Test.txt','r')print(f.readline())f.close()⑨file.readliness()：读取所有行并返回列表，若给定sizeint>0，返回总和大约为sizeint字节的行, 实际读取值可能比 sizeint 较大, 因为需要填充缓冲区f = open('Test.txt','r')print(f.readlines())f.close()⑩file.truncate([size])：从文件的首行首字符开始截断，截断文件为 size 个字符，无 size 表示从当前位置截断；截断之后后面的所有字符被删除，其中 Widnows 系统下的换行代表2个字符大小。⑾file.write()：将字符介入文件，返回的是写入的字符长度⑿file.writelines(sequence)：向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符names=['tom','Jerry','mike']f=open('Test.txt','w',encoding='utf8')names=[name+"\n" for name in names] 推倒表达式 返回一个list+\nf.writelines(names)f.flush()print(names)f.close()

 ④文件操作

#创建空文件，在文件open操作下，w模式也会创建当前打开而不存在的文件目标os.mknod('test.txt')  f = open('test.txt','w')#文件目录操作需要导入的包import os,shutil①获取Python脚本工作的目录路径: os.getcwd()print(os.getcwd())②返回指定目录下的所有文件和目录名:os.listdir()print(os.listdir())  #为空返回当前目录下的所有文件print(os.listdir('股票数据'))  #返回参数目录下的所有文件③删除一个文件:os.remove()print(os.remove('data.pkl'))  #参数‘文件名’④删除多个目录：os.removedirs（r“c：\python”）⑤检验给出的路径是否是一个文件：os.path.isfile()S = os.getcwd()print(S)l = os.path.isfile(S)print(l)⑥检验给出的路径是否是一个目录：os.path.isdir()S = os.getcwd()print(S)l = os.path.isabs(S)print(l)⑦判断是否是绝对路径：os.path.isabs()S = os.getcwd()print(S)l = os.path.isabs(S)print(l)⑧检验给出的路径是否真地存:os.path.exists()S = os.getcwd()print(S)l = os.path.exists(S)print(l)⑨返回一个路径的目录名和文件名:os.path.split()  s = os.path.split('/home/swaroop/byte/code/poem.txt')print(s)>>>('/home/swaroop/byte/code', 'poem.txt')⑽分离扩展名：os.path.splitext()⑾获取路径名：os.path.dirname()⑿获取文件名：os.path.basename()⒀获取文件大小：os.path.getsize（filename）s = os.path.getsize('Test.txt')print(s)#其他附带：'''运行shell命令: os.system()读取和设置环境变量:os.getenv() 与os.putenv()给出当前平台使用的行终止符:os.linesep    Windows使用'\r\n'，Linux使用'\n'而Mac使用'\r'指示你正在使用的平台：os.name       对于Windows，它是'nt'，而对于Linux/Unix用户，它是'posix'重命名：os.rename（old， new）获取文件属性：os.stat（file）修改文件权限与时间戳：os.chmod（file）'''

⑤目录操作

#对应的包import os,shutil@操作①创建目录：os.mkdir('file') ②创建多极目录：s.makedirs（r“c：\python\test”）③删除目录（只能删除空目录）：os.rmdir('file')  ④删除目录(目录所有文件连同删除)：shutil.rmtree('file')⑤移动文件(目录)：shutil.move('oldpos','newpos')⑥重命名文件或者目录：os.rename('oldname','newname')⑦复制文件夹：shutil.copytree('olddir','newdir')  #oldfile只能是文件夹，且newfile必须不存在⑧复制文件：shutil.copyfile('oldfile','newfile')  #oldfile和newfile都只能是文件⑨复制文件：shutil.copy('oldfile','newfile')  #oldfile只能是文件夹，newfile可以是文件，也可以是目标目录⑩转换目录：os.chdir('path')import os,shutilsrc = os.chdir('D:\\Date')  #改变当前目录l = os.getcwd()   # 获取当前路径print('当前的路径为：{}'.format(l))x=open('test.txt','r')print(x.read())x.close()

 12.预定义的清理行为

# 上下文语法：在程序执行结束后关闭进程，释放资源with open('test.txt') as f:    for line in f:         print(line)

 13.python 对象：类（class）

#python类的属性：①__private_attrs：两个下划线开头，声明该属性为私有，不能再类的外部被使用或直接访问。在类内部的方法中使用时self.__private.attrs  @私有变量：__weight = 0 @共有变量：name = ''②self参数：类的方法中必须包含self参数，且为第一个参数，self代表类的实例，可使用this替代但不可缺# 类的实例：class MyClass:    """一个简单的类实例"""    i = 000    def f(self):        return 'hello world' # 实例化类x = MyClass() # 访问类的属性和方法print("MyClass 类的属性 i 为：", x.i)print("MyClass 类的方法 f 输出为：", x.f())>>>MyClass 类的属性 i 为： 000MyClass 类的方法 f 输出为： hello world#__init__()方法：类的实例化操作会自动调用__init__()方法   def __init__(self):    self.data = []   x= MyClass()  #自动调用__init__()方法#__init__()方法的参数class complex:       def __init__(self, realpart, imagpart)             self.r = realpart             self.i = imagpartx = complex(3,4)print(x.r,x.i)>>>3 4# 类的方法：class people:    name = ''    age = 0    # 定义私有属性,私有属性在类外部无法直接进行访问    _weight = 0    def __init__(self, n, a, w):        self.name = n        self.age = a        self.__weight = w    def speak(self):        print("{0} 说：我 {1} 岁了。".format(self.name,self.age))# 实例化类p = people('tom', 10,10)p.speak()>>>tom 说：我 10 岁了。# 类的单继承：class people:    name = ''    age = 0    # 定义私有属性,私有属性在类外部无法直接进行访问    _weight = 0    def __init__(self, n, a, w):        self.name = n        self.age = a        self.__weight = w    def speak(self):        print("{0} 说：我 {1} 岁。".format(self.name,self.age))# 单继承class student(people):    grade = ''    def __init__(self, n, a, w, g):        # 调用父类的构造函数方法        people.__init__(self, n, a, w)        self.grade = g     # 覆写父类方法    def speak(self):        print("{0} 说：我 {1} 岁了，我在读 {2} 年级".format(self.name, self.age, self.grade))if __name__ == '__main__':    s = student('tom', 10, 50 ,3)    s.speak()>>>tom 说：我 10 岁了，我在读 3 年级# 类的多继承：class student(people):    grade = ''    def __init__(self, n, a, w, g):        # 调用父类的构造函数方法        people.__init__(self, n, a, w)        self.grade = g     # 覆写父类方法    def speak(self):        print("{0} 说：我 {1} 岁了，我在读 {2} 年级".format(self.name, self.age, self.grade))class speaker():    topic = ''    name = ''    def __init__(self, n, t):        self.name = n        self.topic = t    def speak(self):        print("我叫{0}，今天我演讲的是{1}".format(self.name, self.topic))# 多重继承class sample(speaker, student):    a = ''    def __init__(self, n, a, w, g, t):        # 调用people和speaker构造函数        student.__init__(self, n, a, w, g)        speaker.__init__(self, n, t)        # 重写父类方法    def speak(self):        print("我叫{}，今年 {} 岁，读{}年级，我是一个小说家，今天我演讲的是{}".format(self.name,self.age,self.grade,self.topic))if __name__ == '__main__':    s = sample('tom', 10, 50 ,3,'python')    s.speak()# 方法重写：super()函数是用于调用父类(超类)的一个方法class Parent:        # 定义父类   def myMethod(self):      print ('调用父类方法') class Child(Parent): # 定义子类   def myMethod(self):      print ('调用子类方法') c = Child()          # 子类实例c.myMethod()         # 子类调用重写方法super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法>>>调用子类方法调用父类方法# 类的私有方法：__Method(self)，私有方法不能被直接进行调用def  __foo(self):     passclass Site:    def __init__(self, name, url):        self.name = name       # public        self.__url = url   # private     def who(self):        print('name  : ', self.name)        print('url : ', self.__url)     def __foo(self):          # 私有方法        print('这是私有方法')     def foo(self):            # 公共方法        print('这是公共方法')        self.__foo() x = Site('菜鸟教程', 'www.runoob.com')x.who()        # 正常输出x.foo()        # 正常输出x.__foo()      # 报错# 类的专有方法：(1).__init__()：构造函数，在生成对象时调用(2).__del__()：析构函数，释放对象时使用(3).__repr__()：打印，转换(4).__setitem__()：按照索引赋值(5).__getitem__()：按照索引取值(6).__len__()：获取长度(7).__cmp__()：比较运算(8).__call__()：函数调用(9).__add__()：加运算(10).__sub__()：减运算(11).__mul__():乘运算(12).__truediv__()：除运算(13).__mod__()：求余运算(14).__pow__()：乘方# 运算符重载class Vector:    def __init__(self, a, b):        self.a = a        self.b =b    def __str__(self):        return 'Vector ({0},{1})'.format(self.a,self.b)    def __add__(self,other):        return Vector(self.a + other.a, self.b + other.b)if __name__ == '__main__':    v1 = Vector(3,4)    v2 = Vector(5,6)    print(v1 + v2)