Python高阶

---

前言

Python很棒，它有很多高级用法值得细细思索，学习使用。本文将根据日常使用，总结介绍Python的一组高级特性，包括：列表推导式、迭代器和生成器、装饰器。

1.多态

# ---------------------------------------------#
#  ((people类->student类),speaker类)->sample类  #
# ---------------------------------------------#
 class people:

     # 基本属性
     name=''
     age=''

     # 私有属性
     _weight=0

     # 构造方法
     def __init__(self,n,a,w):   # 参数
         self.name=n
         self.age=a
         self._weight=w

     def speak(self):
         print('%s 说：我 %d 岁。'%(self.name,self.age))
 class student(people):

     grade=''

     def __init__(self,n,a,w,g):  # 参数

         # 调用父类的构造（继承）
         people.__init__(self,n,a,g)

         # 多态
         self.grade=g                             
         #  ((people类->student类),speaker类)->sample类  #
     # 覆写父类的方法                               
     def speak(self):
         print('%s说：我%d岁了，我在读%d年级'%(self.name,self.age,self.grade))

  s=student('ken',10,60,3)
  s.speak()

2.继承

 class speaker():
     topic=''
     name =''

     def __init__(self,n,t):
         self.name=n
         self.topic=t

     def speak(self):
         print("我叫%s，我是一个演说家，我演讲的主题是%s"%(self.name,self.topic))

 class sample(student,speaker):
     a=''
     def __init__(self,n,a,w,g,t):
         speaker.__init__(self, n, t)    # 继承父类speaker后初始化
         student.__init__(self,n,a,w,g)  # 继承父类student后初始化

 test=sample("Tim",25,80,4,"python")
 test.speak()                            # 方法名相同，默认调用的是在括号中排在前的父类的方法

 print(dir(test))                        # 查看test的方法
 print(vars(test))                       # 查看test的属性值
 print(__dict__(test))

3.qt开发引入库

# qt开发 找不到designer.exe 使用   
pip install PyQt5-tools -i http://pypi.douban.com/simple --trusted-host=pypi.douban.com
# qt开发 基本教程                  https://www.cnblogs.com/agent/p/10816913.html

4.类 静态 实例方法

类方法 @classmethod
静态方法 @staticmethod
实例方法 @objectmethod

 class MethodTest:

     name='hahaha'
     # 成员函数 实例方法 对象方法 成员方法
     def instanceMethod(self):
         print('1.')
         print('instance method')

     # ---------------------------------------------------
     # 类方法    @classmethod
     # 格式      classMethod(cls)
     @classmethod
     def classMethod(cls):
         # 调用类变量 类方法 静态变量
         print('2.')
         print(cls.name)
         print('class method')
     # ---------------------------------------------------
     # 静态方法  @staticmethod
     # 格式     staticMethod()
     @staticmethod
     def staticMethod():
         print('3.')
         print(MethodTest.name)
         print('static method')
#-------------------------------------------------------
#通过类名直接调用类方法 静态方法（推荐）
MethodTest.classMethod()     # 类方法
MethodTest.staticMethod()    # 静态方法
MethodTest.instanceMethod()  # 不能调用成员函数(instanceMethod)方法

# 输出
# --------------------------------------------------#
# ->2.                                              #
# ->hahaha                                          #
# ->class method                                    #
# ->3.                                              #
# ->hahaha                                          #
# ->static method                                   #
# --------------------------------------------------#


m = MethodTest()
# 类方法和静态方法可以通过对象调用（不推荐）
m=MethodTest()               # 实例化
m.classMethod()              # 类方法
m.staticMethod()             # 静态方法
# 输出
# --------------------------------------------------#
# ->2.                                              #
# ->hahaha                                          #
# ->class method                                    #
# ->3.                                              #
# ->hahaha                                          #
# ->static method                                   #
# --------------------------------------------------#

5.私有属性 私有方法

# 私有属性 私有方法
# 通过 set get 方法获取或者修改变量的值
# 通过修饰器 @property @方法名.setter实现
# -------------------------------------------------------#
# 通过修饰器 @property @方法名.setter实现，获取或者修改变量的值 #
                                                        #
 @property                                              #
     def age(self):                                     #
         return self.__age                              #
     @age.setter                                        #
     def age(self,age):                                 #
         self.__age=age                                 #
# ------------------------------------------------------#

6. python实现单例模式 一个类一个实例

1.使用模块
python是天然单例模式，模块第一次导入时会生成.pyc文件
2.使用装饰器
定义装饰器 引用装饰器
3.基于__new__方法实现
生成实例对象时操作
__str__方法有什么用
打印对象的时候自动调用 返回对象信息的字符串
self的含义
指当前对象 本质时当前对象的地址
抽象方法的作用 用来定义 不用实现 包含抽象方法的类不能直接创建对象

 from abc import ABC,abstractmethod
 class Student(ABC):
     def run(self):
         print('run')

     @abstractmethod
     def abstractMathod(self):
         print('')
 class ManStudent(Student):
     def abstractMathod(self):
         print('hahahaha')
 ms=ManStudent()
 ms.abstractMathod()

7. python动态获取和设置类的属性和方法

私有属性 私有方法
通过 set get 方法获取或者修改变量的值

通过修饰器
@property
@方法名.setter实现

python动态获取和设置对象属性
hasattr
getattr
setattr

 class test():                                                                           #
     name='luocheng'                                                                     #
     age=19                                                                              #
     def run(self):                                                                      #
         return 'hello world'                                                            #
                                                                                         #
 t=test()                                          # t=test() 实例对象初始化               #
 print(hasattr(t,'age'))                                                                 #
                                                                                         #
 if hasattr(t,'age'):                              # 如过存在age属性值                     #
     getattr(t,'age',setattr(t,'age','18'))        # 设置age属性值为18                     #
                                                                                         #
 if not hasattr(t,'age'):                          # 如过不存在age属性值                    #
     setattr(t,'age','18')                         # 调价age属性值为18                     #
                                                                                         #
 print(getattr(t,'age'))                                                                 #
 print(hasattr(t,'age'))                                                                 #

8. 对学生成绩进行评级

 import bisect
 def grade(score,breakpoint=[50,60,70,80,90],grades='FEDCBA'):
     i=bisect.bisect(breakpoint,score)
     return grades[i]
 level=grade(78)
 print(level)

# 运行代码
 class A(object):
     def __init__(self,a,b):
         self.__a=a
         self.__b=b

     def myprint(self):
         print('a=',self.__a,'b=',self.__b)

 a1=A(10,20)
 a1.myprint()


 class A(object):
     def __init__(self,a,b):
         self.__a=a
         self.__b=b

     def myprint(self):
         print('a=',self.__a,'b=',self.__b)

     def __call__(self, num):
         print('call:',num+self.__a)

 a1=A(10,20)
 a1.myprint()

 a1(80)

9. 元类 用来创建类的东西 类是原类的实例

python中一切对象要么是类的实例 要么是元类的实例
面向对象中带下划线的特殊方法

 __new__
 __call__               实例对象（）   会执行__call__方法
 __del__                对象在内存中释放时自动触发
 __enter__ __exit__     上下文管理协议
 __module__             当前操作的对象在哪个模块
 __class__              当前操作的对象的类是什么
 __doc__                类的描述信息
 __str__
 __repr__               改变字符串显示
 __format__
 __slot__               一个类变量用来限制实力可以添加的属性数量和数值
 __shot__

10. python魔法方法 给类增加魔力的方法

 __init__               实例创建后调用的初始化方法
 __new__                实例化对象调用的第一个方法
 __cal__                允许一个实例像函数一样调用
 __getitem__            定义获取容器中指定元素行为
 __getattr__            定义用户试图访问一个不存在属性的时候的行为
 __setattr__            定于一个属性被设置的行为
 __getattribute__       定义一个属性被访问的行为

11. 对象中实现 只读属性 将对象私有化 通过公有方法提供一个读取数据的接口

 class person:
     def __init__(self,x):
         self.__age=10
     def age(self):
         return self.__age

 t=person(22)
 #print(t.__age=100)
 print(t.age())

12. OpenCV读图及显示

 import cv2
 img=cv2.imread('psc.jpg')
 cv2.imshow('img',img)
 cv2.waitKey()

13. MySQL使用

 import pymysql
 # 获取连接对象conn，建立数据库的连接
  def get_conn():
      conn = pymysql.connect(host='localhost',port=3306,user='root',passwd='root',db='test')       
 	  # db:表示数据库名称
      return conn
 def insert(sql):
     conn = get_conn()
     cur = conn.cursor()
     result = cur.execute(sql)
     print(result)
     conn.commit()
     cur.close()
     conn.close()
     print('数据库测试成功')

14. 生成注释文件

fp = open("c1.txt", "w")
for i in range(100):
    fp.write("# "+str(i)+"."+"\n")
fp.close()

15. 函数定义

 def counter_letter_number(string):
     m = 0
     n = 0
     for s in string:
         if s in 'abcdefghigklmnopqrstuvwxyzABCDEFGHIGKLMNOPQRSTUVWXYZ':
             m += 1
         elif s in '0123456789':
             n += 1
     return m, n
 print(counter_letter_number("bihb"))
 # 直接返回结果
 def main(): # 无返回结果，因为又是一个函数
     print(counter_letter_number('a1b2c3d4'))

 print(counter_letter_number('a123456b'))
     print(counter_letter_number('123456!!'))
 main()  # 调用

15. 函数定义升级版

 def counter_letter_number(string):
     letter_counter = 0
     digit_counter = 0
     alist = []
     blist = []
     for ch in string:
         if 'a' <= ch <= 'z' or 'A' <= ch <= 'Z':
             letter_counter += 1
             alist.append(ch)
         elif '0' <= ch <= '9':
             digit_counter += 1
             blist.append(ch)
     return letter_counter, alist, digit_counter, blist
 # 无返回
  def main():
      print(counter_letter_number('a1b2c3d4'))
      print(counter_letter_number('a123456b'))
      print(counter_letter_number('123456!!'))
 # 返回
 print(counter_letter_number('a1b2c3d4'))
 print(counter_letter_number('a123456b'))
 print(counter_letter_number('123456!!'))

16. 写函数

 import numpy as np
 def read():
     fp = open("txt2.txt", "w")
     for i in range(1, 101):
         n = np.random.randint(1, 1000)
         fp.write(str(i) + "->" + str(n) + "\n")
     fp.close()

 def main():
     read()

 if __name__ == '__main__':
     main()

17. 写函数升级版

 import random
 def read():
     fp = open("txt3.txt", "w")
     for i in range(1, 101):
         n = random.randint(1, 1000)
         fp.write(str(i) + "->" + str(n) + "\n")
     fp.close()
 def main():
     read()

 if __name__ == '__main__':
     main()

18. 读函数

 def read():
     fp = open("txt2.txt")
     lines = fp.readlines()  # 返回 每行为元素的 列表
     print(lines)
     fp.close()
     return lines
 def main():
         for line in read():
           print(line)
 if __name__ == '__main__':
     main()

19. 数的转换

  dec = int(input("输入数字："))
  print("十进制数为：",dec)
  print("转换为二进制：",bin(dec))

20. 集合运算

# set()转化为集合
 alist = ['a','b','c','d','e','f']
 blist = ['x','y','z','d','e','f']
 blist.sort()
 print(blist)
 print(set(alist))                               # set()转化为集合
 result = list(set(alist).union(set(blist)))     # 集合的并运算 集合a.union集合b 并运算结束后把集合转换成了列表
 print(result)
 result.sort()                                   # 排序
 print(result)

 result.reverse()
 print(result)

21. 字符串倒序排列

 #因字符串无法直接倒序排列，所以先把字符串转化为列表，然背对列表倒序排列
 s = 'asjhjhjnl'
 clist = list(s)          # 字符串转列表
 print(clist)             # 已经转换成了列表
 clist.reverse()          # 倒序排列
 print(clist)             # 已经转换成了列表
 # ---------------------------------------------------------------
 print("".join(clist))    # 列表转字符串
 # ---------------------------------------------------------------
 print(clist)             # 打印字符串

22. 列表计算

 a = ['abc']
 b = ['def']
 a.append('g')
 print(a)
 c = a.append(b)
 print(a)
 d = [a[0]+'g']
 print(d)

23. 列表生成式

 l1 = [x*x for x in range(1,11)]
 print(l1)
 l2 = [x*x for x in range(1,11) if x%2==0]
 print(l2)

24. 格式输出函数

 c = (250, 250)

 print("坐标：%s" % (c,))        # 格式
 print("坐标：{}".format(c))     # 格式

25. 字符串操作

 a1=[]
 b1=[]
 c1=[]
 def find1(string):
     for i in string:
         if 'a' <= i <= 'z':
             a1.append(i)
         elif 'A' <= i <= 'Z':
             b1.append(i)
         elif '0' <= i <= '9':
             c1.append(i)
     return a1,b1,c1

 print(find1("qnhjTG89"))        # 返回a1,b1,c1三个单独列表
 print("小写字母","".join(a1))    #     qnhj         列表转换为字符；字符直接转化为列表 a=list（string）
 print("大写字母","".join(b1))
 print("数字","".join(c1))

 print("小写字母",",".join(a1))    #    q,n,h,j      列表转换为字符；字符直接转化为列表 a=list（string）
 print("大写字母",",".join(b1))
 print("数字",",".join(c1))

26. 字典操作

 dict={
    
    'k': '1', 'k1': '2', 'k2': '3', 'k3': '4', 'k4': '5'}
 print(dict['k2'])

 # 切片
 str1 = "k:1*k1:2*k2:3*k3:4*k4:5"
 print(str1.split('*'))   # 返回列表

 # 字典生成
 dict1 = {
    
    }

 str1='k1:1'
 str2='k2:2'

 key, value = str1.split(':')
 dict1[key] = value
 print(dict1)

 key, value = str2.split(':')
 dict1[key] = value
 print(dict1)

27. 字符转字典

 str1 = "k:1|k1:2|k2:3|k3:4|k4:5"
 def str2dict(str1):
     dict1 = {
    
    }
     for iterms in str1.split('|'):     # |处切片进行迭代,返回列表,相当于列表迭代 ['k:1', 'k1:2', 'k2:3', 'k3:4', 'k4:5']
         key,value = iterms.split(':')  # :处切片进行定义                      iterms = 'k:1'
         dict1[key] = value             # 新字典生成
     return dict1

 print(str2dict(str1))  # 调用函数

28. 列表生成

 li = list(range(10))
 print([x for x in range(10)])
 print(range(10))
 print(li)
 print(li[1::])

29. 大小写转化

L = ['HH','Jjjj','JJJPOPOkkk']
 f='njnwNJNJKKkmKMk;;Mm;'
 print([s.lower() for s in L])  # 大写转小写
 print([s.upper() for s in L])  # 小写转大写
 print(f.lower())               # njnwnjnjkkkmkmk;;mm;

30. 斐波拉且数列

 a = 0
 b = 1
 while b < 10:
     print(b)
     a, b = b, a+b             # a,b=b,a+b这个表达式的意思就是说先计算=号的右边b的值，a+b的值，然后再分别赋值给a 和b
     # a = b
     # b = a + b               #

31. 打印星星

 def printGraph(n):                  # n为行数
     for i in range(1, n+1):         # i为行数
         for j in range(1, n-i+1):   # 计算每行行首空格数
             print(' ', end='')      # 打印每行行首空格数
         for k in range(1, 2*i):     # 计算每行星星数
             print('*', end='')      # 打印每行星星数
         print('')                   # 每行行尾打印空行

 printGraph(8)

32.打印星星升级版

 def printGraph(n):
     for i in range(1,n+1):
         print(    ' '*(n-i)    +     '*'*(2*i-1)     )

 printGraph(8)

33.查看当前目录下的文件

 import os
 a=[]
 for d in os.listdir('.'):
     a.append(d)
 print(a)
 print(len(a))
 for i in range(len(a)):
     if i % 5 == 0:
         print('\n')
     else:
         print(a[i])

34.查看当前目录下的文件升级版

 import os
 [print(d) for d in os.listdir('.')]

35.生成随机数，写入到文件中

 import random
 fp=open("abc.txt","w")
 for i in range(1,101):
     n=random.randint(1,1000)
     fp.write(     str(i)     +"->"    +str(n)    +    "\n")
 fp.close()

36.查看某个目录下的文件

 import os
 def print_dir(input1):
     #filepath=input("请输入路径：")
     filepath = input1
     if filepath=="":
         print("请输入正确路径")
     else:
         for i in os.listdir(filepath):
             print(os.path.join(filepath,i))    # print("".join(clist))    # 列表转字符串

 print(print_dir(input("请输入路径：")))

37.打印九九乘法表

 for i in range(1,10):                        # 行
     for j in range(1,i+1):                   # 列
         print('%d*%d=%d'%(j,i,j*i),end='\t')
     print('')

38.打印倒三角

 def printGraph(n):
     for i in range(1,n+1):
         print(     ' '*(i-1)      +    '*'*(2*(n-i)+1)    )
 printGraph(8)

39.os和sys，os与操作系统有关，sys与程序和解释器有关

 1,2,3,4,5生成互不相同的无重复三位数

 i = 0
 for x in range(1,6):
     for y in range(1,6):
         for z in range(1,6):
             if (x!=y) and (y!=z) and (z!=x):
                 i+=1                                  # i 表示生成三位数的个数
                 if i%6:                               # i%6=1,2,3,4,5,0,1,2,3,4,5,0,1,2,3,4,5,0.非零为真，为零为假
                     print("%d%d%d"%(x,y,z),end="|")   # 前五个
                 else:
                     print("%d%d%d"%(x,y,z))           # 第六个

 for i in range(24):
     if i % 6:
         print('*',end=' ')
     else:
         print(' ')
 

#-----------#
#类->无参数 #
#-----------#

 class Student:
     def __init__(self):  # 无参数占位
         # 类属性
         self.name='zhangsan'
         self.age=12
         self.dda='sss'

     def shopping(self,item):
         print('buy %s'%item)

 s=Student()  # 实例化，无参数
 print(s.name)
 print(s.dda)
 print(s.age)

 

#-----------#
# 类->有参数#
#-----------#

 class Student:
     def __init__(self,sss):  # 参数占位
         self.name='zhangsan'
         self.age=12
         # 实例属性
         self.dda=sss

     def shopping(self,item):
         print('buy %s'%item)

 s=Student('cvdecv')  # 实例化，有参数
 print(s.name)
 print(s.dda)
 print(s.age)

40.pickle序列化和反序列化

 import pickle
 class Student:
     def __init__(self):
         self.name='zhangsan'
         self.age=12
                                #------------#
     def shopping(self,item):   # 不知道有啥用 #
         print('buy %s'%item)   # 不知道有啥用 #
                                #------------#
 s=Student()
 print(s.name)
 # pickle.dumps序列化，相当于加密
 info=pickle.dumps(s)
 print(info)
 # pickle.loads反序列化，相当于解码
 s2=pickle.loads(info)
 print(s2.name)

41.pickle序列化和反序列化升级版

 import pickle

 class Student:

     def __init__(self):
         self.name = 'zhangsan'     # 属性
         self.age = 12              # 属性

     def shopping(self, item):      # 方法
         print('buy%s'%item)        # 方法

 s = Student()

 with open('stu2.data', 'wb') as fr:
     pickle.dump(s, fr)

 with open('stu2.data', 'rb') as fr:
     s1=pickle.load(fr)

 print(s.age)
 print(s.name)
 print(s.shopping('cai'))

42.with打开文件自动带了异常处理

 import os

 baseDir=r'C:\Users\Administrator\PycharmProjects\python进阶'
 filename='abc.txt'

 file_path=os.path.join(baseDir,filename)

 with open(file_path,'r') as f:
     print(f)
     print(f.readlines())
 #    for line in f.readlines():
 #        print(line)

43.列出当前目录下所有文件和文件夹名

 import os
 for d in os.listdir('.'):
     print(d)

44.获取字符串中某个字符的个数

 #-------- 统计每个字符出现个数 ---------#
 from collections import Counter             
 s='vhjvvc cjk kuebvuce'
 c1=Counter(s)
 print(type(c1))
 print(dict(c1))
 print(Counter([2,4,2,5,6,2]))

45.用python标准库实现输入某年某月某日，判断这一天是这一年的第几天

 import datetime
 def dayofyear():
     year =input("请输入年份：")
     month=input("请输入月份：")
     day  =input("请输入天：  ")
     date1 = datetime.date(year=int(year), month=int(month), day=int(day))
     date2 = datetime.date(year=int(year), month=1, day=1)
     return (date1-date2).days

 print(dayofyear())

46.计算一个数的阶乘

 num=int(input("请输入一个正整数："))
 result=1
 for i in range(2,num+1):  # 从2开始循环，最后一个数不参与循环 #
     result *= i  # result=result*i
 print("%d的阶乘为："%num,result)

47.使用json数据处理方式查找字符串

{“person”:[{“name”:“yu”,“age”:“23”},{“name”:“zhang”,“age”:“34”}]}第一个姓名
无法运行32.计算一个数的阶乘

 import json
 j=json.loads('{"person":[{"name":"yu","age":"23"},{"name":"zhang","age":"34"}]}')
 print(j.values[0][0]['name'])

48.定义函数

 def hello():
     print("hello world!")
 hello()

49.lamda函数，匿名函数；def用来创建有名称的函数。

50.单下划线和双下划线的区别

 # 类的定义是否继承object，有什么区别，
 # 不继承object对象，只拥有了__doc__ , __module__ 和 自己定义的name变量
 # 承了object对象，拥有了好多可操作对象，这些都是类中的高级特性
 class Method(object):

     def __init__(self,name,age,sex):
         # self.__name=name   # 私有
         self.name = name     # 公有
         self.age  = age      # 公有
         self.sex  = sex      # 公有

     def sayhello(self):
         print("Method say hello!")

     def __sayhi(self):       # 私有
         print("Method say hi!")

 m=Method('axsa','acs','cacsa')

 m.sayhello()
 # m.__sayhi()
 # print(m.__name)
 print(m.name)

51.字符串的倒序排列

#------------------#
# 字符串的倒序排列 #
#------------------#

 def string_reverse(input_str):
     return input_str[::-1]

 print(string_reverse("abcdefg"))

52.字符串的倒序排列32.计算一个数的阶乘

 string="abcdefg"
 clist=list(string)
 clist.reverse()
 print("".join(clist))  # 列表转字符串

53.随便编写

 class A(object):
     def __init__(self,a,b):
         self.a1=a
         self.a2=b
         print('init')

 a1=A(1,'s')

54.计算x的n次方

 def power(x,n): # x=2 n=4 说明x 乘3次   （n-1）次
     s=1
     while n>0:
         n=n-1
         s=s*x
     return s

 print(power(2,4))

55.形参，实参问题

 def funcF(a, **b):
   print(a)
   print(b)
   for x in b:                  # x为索引，索引的值为b[x]
     print(x + ":" + str(b[x]))

 funcF(100, c='你好', b=200)

56.计算一个数的阶乘

'''
args 和 **kwargs 主要用于函数定义。
可以将不定数量的参数传递给一个函数。不定的意思是：预先并不知道, 函数使用者会传递多少个参数给你, 所以在这个场景下使用这两个关键字。其实并
是必须写成 *args 和 **kwargs。  *(星号) 才是必须的. 你也可以写成 *ar  和 **k 。而写成 *args 和**kwargs 只是一个通俗的命名约定。
-----------------------------------------------------------------------------------------------------------------------
args 与 **kwargs 的区别，两者都是 python 中的可变参数：
args 表示任何多个无名参数，它本质是一个 tuple
*kwargs 表示关键字参数，它本质上是一个 dict

'''

 # 如果同时使用 *args 和 **kwargs 时，必须 *args 参数列要在 **kwargs 之前。
 def fun(*args, **kwargs):
     print('args=', args)
     print('kwargs=', kwargs)
 fun(1, 2, 3, 4, A='a', B='b', C='c', D='d')

 # 使用 *args
 def fun(name, *args):
     print('你好:', name)
     for i in args:
         print("你的宠物有:", i)
 fun("Geek", "dog", "cat")

 # 使用 **kwargs
 def fun(**kwargs):
     for key, value in kwargs.items():
         print("{0} 喜欢 {1}".format(key, value))
 fun(Geek="cat", cat="box")

 # 如果函数的形参是定长参数，也可以使用 *args 和 **kwargs 调用函数，类似对元组和字典进行解引用
 def fun(data1, data2, data3):
     print("data1: ", data1)
     print("data2: ", data2)
     print("data3: ", data3)

 args = ("one", 2, 3)
 fun(*args)

 kwargs = {
    
    "data3": "one", "data2": 2, "data1": 3}
 fun(**kwargs)

56.计算aa+bb+cc+ 定义函数不确定有多少参数时，可用来表示多个参数

 # 参数为元组
 def calc(*numbers):  
     sum=0
     for n in numbers:
         sum=sum+n*n
     return sum

 print(calc(2,4,5,6))

57.打印1-10的数字及每个数的平方

 # 阶乘 factorial
 from math import factorial  
 def main():
     print('%-10s%-10s%-10s%-10s' % ('数字', '平方', '几何级数', '阶乘'))
     for num in range(1, 11):
         print('%-12d%-12d%-12d%-12d' % (num, num**2, 2**num, factorial(num)))

 if __name__ == '__main__':
     main()

58.生成验证码

 from random import randint
 def generate_code(length=4):
     code_string='qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM1234567890'
     code=''
     print(len(code_string)-1)

     for _ in range(length):
         code += code_string[randint(0, len(code_string)-1)]  #randint(0, len(code_string)-1)为0，61之间的随机数，code_string列表
     return code

 def main():
     for _ in range(10):
         print(generate_code())

 if __name__ =='__main__':
     main()

59.统计字符串中中英文出现的次数

 def count_letter(string):
     m=0
     n=0
     for s in string:
         if s in 'qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM':
             m+=1
         elif s in '1234567890':
             n+=1
     return m, n

 def main():
     print(count_letter('bjjnjn3j-=-jk44j43'))
     print(count_letter('by87387=-t48'))
     print(count_letter('hjbNN 99  PPU*Y77'))

 if __name__ =='__main__':
     main()

60.python执行shell脚本返回结果

 import subprocess
 result = subprocess.getoutput('dir')
 print(result)

61.输出某个路径下所有文件和文件夹的路径

 import os
 def print_dir():
     filepath=input('请输入路径：')
     if filepath=='':
         print('请输入正确的路径')
     else:
         for i in os.listdir(filepath):
             print(os.path.join(filepath,i))
 print(print_dir())

62.输出某个路径下及其目录下的所有文件路径

 import os
 def show_dir(filepath):
     for i in os.listdir(filepath):
         path=(os.path.join(filepath,i))
         print(path)
         if os.path.isdir(path):  # 判断是否是目录,如果为真,则继续执行
             show_dir(path)       # 如果是目录，采用递归的方式
 filepath='C:\Program Files'
 show_dir(filepath)

63.列出当前目录下所有目录及文件夹名

 import os
 for d in os.listdir('.'):
     print(d)

64.输出某个路径及其子目录下所有以html为后缀的文件

 import os
 def print_dir(filepath):
     for i in os.listdir(filepath):
         path=os.path.join(filepath,i)  # path为路径

         # if os.path.isdir(path):        # 判断路径是否是文件夹，如果是文件夹则递归，如果不是文件夹则执行下一行

         #     print_dir(path)
         if path.endswith('.pdf'):     # 判断文件是否是html,如果是则打印,如果不是,则不做操作
             print(path)

 filepath='C:\\Users\\Administrator\\Documents'
 print_dir(filepath)

65.计算一个数的阶乘

 import os
 def print_dir(filepath):
     for i in os.listdir(filepath):
         path=os.path.join(filepath,i)  # path为路径
         print(path)

 filepath='C:\\Users\\Administrator\\Documents'
 print(print_dir(filepath))

66.生成100个数，然后写入文件

 import random
 fp=open('aa.txt','w')
 for i in range(1,101):
     n=random.randint(1,1000)
     fp.write(str(i)+'->'+str(n)+'\n')
 fp.close()

67.逐行读入utf-8编码的文件打印在屏幕上

 # coding=utf-8
 import chardet  # 查看字符串编码方式的模块
 fp=open('abc.txt','r')
 lines=fp.readlines()
 fp.close()

 for line in lines:
     print(line.decode('utf-8').encode('gbk','ignore'))

68.删除文件

 import os
 file=r'C:\Users\Administrator\PycharmProjects\python进阶\ab.txt'
 if os.path.exists(file):
     os.remove(file)
     print('delete sucess')
 else:
     print('no such file:%s' %file)

69.获取当前目录

 import os
 os.getcwd()  # 获取当前目录

70.修改当前目录

 import os
  # 更改目录
 print(type(os.chdir('C:\\Users\\Administrator\\PycharmProjects\\python进阶') ))

71.以相反顺序展示一个文件的内容

 for line in reversed(list(open('c.txt'))):
     print(line.rstrip)

72.设置一个函数，返回给定文件的后缀名

 def get_suffix(filename,has_dot=False):
     pos=filename.rfind('.')              # 返回数值pos   点 位置的索引值
     print(pos)
     if 0<pos<len(filename)-1:
         #------------------------------------------------------#

         # index=pos if has_dot else pos+1  # 返回pos+1
         if has_dot:
             index = pos
         else:
             index=pos + 1
         return filename[index:]
         #------------------------------------------------------#

     else:
         return ''
 print(get_suffix('vbgedfvbda.txt'))

 #精简版
 def get_suffix(filename,has_dot=False):
     pos   = filename.rfind('.')               # 返回数值pos
     index = pos+1                             # 返回pos+1
     return filename[index:]
 print(get_suffix('vbgedfvbda.txt'))


 返回给定文件的后缀名
 print(('dhdhdh.xls')[(('dhdhdh.xls').rfind('.')):])

73.返回给定文件的 名称和后缀名

os.path.splitext(file) 返回元组 <class ‘tuple’>

 import os
 print(os.path.splitext('a.yxy'),type(os.path.splitext('a.yxy')))

 print(os.path.splitext('a.yxy')[1])

74.返回给定文件的后缀名

 a = 'vbgedfvbda.txt'
 pos=a.rfind('.')
 print(a[pos:])

75.生成随机数

 import random
 print(random.random())                 # 0~1之间浮点型随机数
 print(random.randint(2,4))             # 2~4之间整形随机数
 print(random.randrange(2,8,2))         # step=2的随机数
 print(random.uniform(10,20))           # 10~20浮点型随机数
 print(random.choice('dnnjksjkji'))     # 随即提取一个字符

 

76.可以使用随即提取字符的方式生成验证码

 import random
 for i in range(4):
     print(random.choice('dnnjksjkji'),end='')

77.从指定序列中随机获取指定长度的片段

 import random
 list1=[1,2,4,'edd',56,'da']
 print(random.sample(list1,3))  # 指定序列中随机获取指定长度的片段
 print(random.sample(list1,3))  # 指定序列中随机获取指定长度的片段
 print(random.sample(list1,3))  # 指定序列中随机获取指定长度的片段
 print(random.sample(list1,3))  # 指定序列中随机获取指定长度的片段

78.打乱一个排好序的list对象

 import random
 list2=[23,5,55,756,211,131]       # 生成列表


 random.shuffle(list2)             # 打乱列表
 print(list2)

 random.shuffle(list2)             # 打乱列表
 print(list2)

 random.shuffle(list2)             # 打乱列表
 print(list2)

 random.shuffle(list2)             # 打乱列表
 print(list2)

79.生成验证码的两种方式

 import random
 list3=[]

 for i in range(65, 91):       # A-Z
     list3.append(chr(i))
 for j in range(97, 123):      # a-z
     list3.append(chr(j))
 for k in range(48, 58):       # 0-9
     list3.append(chr(k))

 # list3=['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
 # print(list3)

 ma = random.sample(list3, 6)  # 指定序列中随机获取指定长度的片段
 print(ma)
 ma = ''.join(ma)
 print(ma)

80.以函数为参数返回一个替换函数的可执行函数

 
 #构造器 
 def __init__(self,,,,):

81.类传入外部参数全靠构造函数

 class fib:
     def __init__(self):
         self.xxt=29

 f=fib()
 print(f.xxt)
print()

#----------------------------------------------------------------------#
 class fib:                                                           #
     def __init__(self,name):                                         #
         self.age=29                                                  #
         self.sex='femal'                                             #
         self.value=name                                              #
                                                                      #
 f=fib('xxt')                                                         #
 print('name',f.value,'\n','age',f.age,'\n','sex',f.sex)              #
 print('name',f.value,'\t','age',f.age,'\t','sex',f.sex)              #
#----------------------------------------------------------------------#

82.简单生成器

 
 L=[x*x for x in range(3)]  # []列表
 g=(x*x for x in range(3))  # ()迭代器

 print(L)         # 列表可直接打印
 print(g)         # 迭代器不能直接打印
 for i in g:      # 循环打印
     print(i)     # 循环打印

83.带有yield语句的生成器 return返回值时不保留当前信息，yield返回值时会保留当前信息

 import sys                      # 跟编译器相关
 def fibobacci(n):
     a, b, counter = 0, 1, 0
     while True:
         if ( counter > n ):
             return
         yield a                 # 带有yield语句的生成器 return返回值时不保留当前信息，yield返回值时会保留当前信息
         a, b = b, a+b           # 先计算右边再复制给左边
         counter += 1

 f=fibobacci(10)

 while True:
     try:
         print(next(f), end='\t')
     except StopIteration:
         sys.exit()

84. 简单的迭代器迭代器 有两个基本语法 iter()和next()可以使用collections模块判断一个对象是否是迭代器

 
 list=[1,2,3,4]
 it=iter(list)
 for x in it:
     print(x)

 from collections import Iterable

 print(isinstance('asdfc',Iterable))         # True
 print(isinstance([1,23,444],Iterable))      # True
 print(isinstance(2332,Iterable))            # False
 print(isinstance((1,2,45,6),Iterable))      # True
 print(isinstance({
    
    1,23,53,12},Iterable))    # True

 # 85. 类的迭代使用，需要__iter__和__next__
 class MyNumbers:
     def __iter__(self):
         self.a=1
         return self

     def __next__(self):
         x=self.a          # self.a=1
         self.a+=1         # self.a+=1
         return x          # 返回的x在print中打印

 myclass = MyNumbers()
 myiter  = iter(myclass)

 print(next(myiter))
 print(next(myiter))
 print(next(myiter))
 print(next(myiter))
 print(next(myiter))

86.isinstance和type检测某一变量是否是某一类型，某一实例是否属于某一类

 a=10
 print(type(a)==int)                                # type(a)==int
 print(isinstance(a,int))                           # isinstance(a,int)
 print(isinstance(a,str))                           #
 print(isinstance(a,(str,int,list)))                # isinstance(a,(str,int,list))

87.浅拷贝、深拷贝、赋值

 import copy as cp
 a=[1,2,3,4,['a','b']]
 b=a                       # a，b完全是一个东西

 c=cp.copy(a)              # 浅拷贝

 # 增加列表元素        不能浅拷贝
 # 列表的某个元素更改   可以浅拷贝

 d=cp.deepcopy(a)          # 单独拷贝a一份，拷贝结束，不在有关联，为初始a=[1,2,3,4,['a','b']]

 a.append(5)               # 增加列表元素        不能浅拷贝
 a[4].append('c')          # 列表的某个元素更改   可以浅拷贝
 a[0]=66

 print('a=', a)
 print('b=', b)
 print('c=', c)
 print('d=', d)

88.map函数，根据提供函数对指定序列进行映射，相当于一次性求解多个值

 #--------------------------------------------------------------- #
 def square(x):                                                  #
     return x**2                                                 #
 print(list(map(square,[1,2,3,4,5])))          # square后无括号  #
 print(list(map(lambda x:x**2,[1,2,3,4,5])))                     #
                                                                 #
 print(list(map(lambda x,y:x+y,[1,2,3,4,5],[3,5,76,2])))         #
 #--------------------------------------------------------------- #

89.reduce函数,对参数序列中的元素进行积累

 from functools import reduce
 def add(x,y):
     return x+y

 r=reduce(add,[1,2,34,4])
 print(r)

90.reduce函数,对参数序列中的元素进行积累 reduce(函数，[迭代序列])

from functools import reduce
def chen(x,y):
    return x*y
print(reduce(chen,[i for i in range(1,(int(input('请输入:'))+1))]))

91.filter函数，过滤函数 返回序列

 from collections import *

 def isOdd(n):
     return n%2==1  # 余数为1

 def isOdd(n):
     if n%2==1:
         return n

 f=filter(isOdd,[1,2,3,45,6,7,8,432,1])
 print(list(f))

92.enumerate函数，返回枚举对象函数,可迭代

 seasons=['dwe','qdw','dqq']
 print(enumerate(seasons))
 print(list(enumerate(seasons)))

93.zip函数，拉链函数 返回列表

 list1=[1,3,46,5]
 list2=['ss','ds','fr','qw']
 list3=[32,322,433,2322]

 ziped=zip(list1,list2,list3)
 print(list(ziped))                                   
 # [(1, 'ss', 32), (3, 'ds', 322), (46, 'fr', 433), (5, 'qw', 2322)]

94.hasattr()判断一个对象是否有name属性和方法

----------------------------------------------------------------------

 class function_demo(object):

     name='demo'                        # 属性(自身属性值)

     def run(self):                     # 方法(无参数)
         return "hello function"

     def run1(self,dog):                # 函数(有参数)
         return "hello function "+dog

 functiondemo=function_demo()
 print(hasattr(functiondemo,'name'))
 print(hasattr(functiondemo, 'run'))
 print(hasattr(functiondemo, 'age'))
 print(functiondemo.run1('pig'))

95.getattr()获取对象属性和方法

class function_demo(object):
    name='demo'
    def run(self):
        return "hello function"

functiondemo=function_demo()
print(getattr(functiondemo,'name'))  # 返回姓名
print(getattr(functiondemo, 'run'))  # 返回地址

96.setattr()给对象属性进行赋值

class function_demo(object):
    name='demo'
    def run(self):
        return "hello function"

functiondemo=function_demo()
print(hasattr(functiondemo,'name'))  # 判断属性是否存在
setattr(functiondemo,'age',18)       # 属性赋值,相当于age=18
print(hasattr(functiondemo, 'age'))  # 判断属性是否存在

97.正则表达式//也称为规则表达式81.match函数

 #match('匹配则正则表达式','要匹配的字符串',控制表达式匹配模式)
 import re
 m = re.match('www', 'Www.mobiletrain.org', re.I)

 if m != None:
     print(type(m.group()))
     print((m.group().lower()))
     print(m.group())  # group和groups返回匹配结果，    Www
     print(m.span())   # 匹配结果标志位                (0, 3)

 print(type(m.group()))
 print((m.group().lower()))
 print(m.group())  # group和groups返回匹配结果，    Www
 print(m.span())   # 匹配结果标志位                (0, 3)

98.search函数

 import re
 print(re.search('www','www.taop.com'))     # <_sre.SRE_Match object; span=(0, 3), match='www'>
 print(re.search('www','.wwwtam,mm.com'))   # <_sre.SRE_Match object; span=(1, 4), match='www'>

99.findall函数

 import re
 pattern=re.compile(r'\d+')   # 查找数字
 result1=pattern.findall('' 'cwcww4422 fwwcfw2rrrc  fc 34')   # 查找数字
 result2=pattern.findall('cafev424rvevevd355cfcctfd5',0,10)   # 查找数字

 print(result1)
 print(result2)


 print('hhdhdh.cvc2'.rfind('2'))

100.finditer函数

 import re
 it=re.finditer(r'\d+','13ecwe5345fe52rwf4535vvwvc dcx32')
 for match in it:
     print(match.group())

101.compile函数

 import re
 pattern=re.compile(r'\d+')
 m=pattern.match('one12dcvkio230uiu9fkjfksm kfkl opi9i0')
 print(m)
 m=pattern.match('one12dcvkio230uiu9fkjfksm kfkl opi9i0',2,20)
 print(m)
 m=pattern.match('one12dcvkio230uiu9fkjfksm kfkl opi9i0',3,20)
 print(m)
 #print(m.groups())
 print(m.group(0))
 print(m.start(0))
 print(m.end(0))
 print(m.span(0))

102.sub函数 re.sub(正则表达式模式，替换字符串，要被查找替换的原字符串，模式匹配后要替换的最大次数)

 import re
 phone='199-4629-0552'  # gaagcec

 num1=re.sub(r'#.*$','',phone)
 print('电话号码：',num1)

 num2=re.sub('#.*$','',phone)
 print('电话号码：',num2)

 num3=re.sub(r'#','',phone)
 print('电话号码：',num3)

 num4=re.sub(r'\D+','',phone)
 print('电话号码：',num4)

 num5=re.sub(r'\D','',phone)
 print('电话号码：',num5)

103.re

 import re

 def double(matched):
     value=int(matched.group('value'))
     return str(value*2)

 s='a321mk3455kk523km'
 print(re.sub('(?P<value>\d+)',double,s))
 

104.split函数

 import re
 print(re.split('\W+','lhrxxt,lhrxxt,lhrxxt.'))
 print(re.split('(\W+)','lhrxxt,lhrxxt,lhrxxt.'))
 print(re.split('\W+','lhrxxt,lhrxxt,lhrxxt.',1))
 print(re.split('a*','hello world!'))

106.其他 92.选择排序

 # 数据结构
 def select_sort(lists):
     count=len(lists)
     for i in range(count):
         min=1  # 第一个元素
         for j in range(i+1,count):  # 第二个元素以后
             if lists[min]>lists[j]:
                 min=j
         lists[min],lists[i]=lists[i],lists[min]
     return lists

 if __name__=="__main__":
     lists0=[3,4,28,9,5,1]
     print("排序前的数组为：",lists0)
     print("排序后的数组为：",[i for i in (select_sort(lists0))])

107.插入排序

 def insert_sort(lists):
     count=len(lists)
     for i in range(1,count):
         key=lists[i]
         j=i-1
         while j>=0:
             if lists[j]>key:
                 lists[j+1]=lists[j]
                 lists[j]=key
             j-=1
     return lists

 if __name__=="__main__":
     lists0=[3,4,28,9,5,1]
     print("排序前的数组为：",lists0)
     print("排序后的数组为：",[i for i in insert_sort(lists0)])

108.冒泡排序

 def bubble_sort(lists):
     for i in range(len(lists)-1):
         for j in range(len(lists)-i-1):
             if lists[j]>lists[j+1]:
                 lists[j],lists[j+1]=lists[j+1],lists[j]
     return lists

 if __name__=="__main__":
     lists0=[3,4,28,9,5,1]
     print("排序前的数组为：",lists0)
     print("排序后的数组为：",[i for i in bubble_sort(lists0)])

109.归并排序

 不能运行
 def merge(left,right):
     i,j=0,0
     result=[]
     while i<len(left)and j<len(right):
         if left[i]<=right[j]:
             result.append(left[i])
             i+=1
         else:
             result.append(right[j])
     result+=left[i:]
     result+=right[j:]
     return result

 def merge_sort(lists):
     if len(lists)<=1:
         return lists
     num=len(lists)/2
     left=merge_sort(lists[:num])
     right=merge_sort(lists[num:])
     return merge(left,right)

 if __name__=="__main__":
     lists0=[3,4,28,9,5,1]
     print("排序前的数组为：",lists0)
     print("排序后的数组为：",[i for i in merge_sort(lists0)])

110.快速排序

 def quick_sort(lists,left,right):
     if left>=right:
         return lists
     key=lists[left]
     low=left
     hight=right
     while left<right:
         while left<right and lists[right]>=key:
             right-=1
         lists[right]=lists[left]
         while left<right and lists[left]<=key:
             left+=1
         lists[right]=lists[left]
     lists[right]=key
     quick_sort(lists,low,left-1)
     quick_sort(lists,left+1,hight)
     return lists

 if __name__=="__main__":
     lists0=[3,4,28,9,5,1]
     print("排序前的数组为：",lists0)
     print("排序后的数组为：",[i for i in quick_sort(lists0,0,len(lists0)-1)])

111.希尔排序

 def shell_sort(lists):
     count=len(lists)
     step=2
     group=count/step
     while group>0:
         for i in range(0,group):
             j=i+group
             while j<count:
                 k=j-group
                 key=lists[i]
                 while k>+0:
                     if lists[k]>key:
                         lists[k+group]=lists[k]
                         lists[k]=key
                     k-=group
                 j+=group
         group/=step
     return lists

 if __name__=="__main__":
     lists0=[3,4,28,9,5,1]
     print("排序前的数组为：",lists0)
     print("排序后的数组为：",[i for i in shell_sort(lists0)])

112.基数排序

 class Solution(object):

     def findmedian(self, lists):
         if not lists or len(lists) == 0:
             return []
         n = len(lists)
         if n % 2 == 0:
             a = self.partition(lists, n / 2, 0, n - 1)
             b = self.partition(lists, n / 2 - 1, 0, n - 1)
             mid = (lists[a] + lists[b]) / (2 * 1.0)
             return mid
         else:
             mid = self.partition(lists, n / 2, 0, n - 1)
             return lists[mid]

     def partition(self, lists, k, start, end):

         key = lists[start]
         left, right = start, end

         while left < right:
             while left < right and lists[right] > key:
                 right = right - 1
             lists[left] = lists[right]

             while left < right and lists[left] < key:
                 left = left + 1
             lists[right] = lists[left]

         lists[left] = key

         if left == k:
             return left
         elif left > k:
             return self.partition(lists, k, start, left - 1)
         else:
             return self.partition(lists, k, left + 1, end)

 if __name__ == "__main__":
     sol = Solution()
     lists = [2, 5, 4, 9, 3, 6, 8, 7, 1]
     # lists = [1, 2]

     data = sol.findmedian(lists)
     print("中位数 = %s" % data)

113.创建文档

 fp = open("c1.txt", "w")
 for i in range(35,100):
     fp.write("# "+str(i)+"."+"\n")
 fp.close()

114.给定一个有序表，输出要插入的值k所在索引

 def index(list,key):
     for i in range(len(list)):
         if key<list[0]:
             position = 0
             return position
         elif key>list[-1]:
             position=len(list)
         else:
             for i in range(len(list)):
                 if key > list[i] and key < list[i + 1]:
                     position = i + 1
                     return position

 print(index([0,1,3,5,7,9],4))

115.编写一个函数，实现数字或者字符的链接

 
 def v1(addr):
     id=[str(x) for x in addr.split('.')]  # str(x)转为字符串
     print(id)
     list3 = ''.join(id)                   # Python join() 方法用于将序列中的元素（必须是str） 以指定的字符 连接生成一个新的字符串。
     print(list3)

 v1('10.3.9.12')            # 直接调用
 print(v1('10.3.9.12'))     # 打印调用来的打印

116.编写一个函数，实现将IP地址转换为一个整数

 
 def v1(addr):
     id=[int(x) for x in addr.split('.')]  # int(x)转为字符串
     print(id)
     return sum(id[i] << [24, 16, 8, 0][i] for i in range(4))    # Python-位操作( &、 | 、^、~ 、>>、 <<)
     # sum(iterable[, start]) sum对迭代器中所有元素求和
 print(v1('10.3.9.12'))

117.判断一个字符串是否以特定字符结尾？

 
 Str='nihaoer'
 print(Str.endswith('er'))
 Str='nihaoer.er'
 print(Str.endswith('er.er'))

 
 # 替换字符串中特定字符
 Str='#nih#a#o####################er'
 print(Str.replace('#','').strip())
 print(Str.replace('#',''))


 # 判断奇偶数的经典算法
 #------------------------------#
 def f(x):                      #
     if x%2==0:                 #
         return 0               #
     else:                      #
         return 1               #
                                #
 b=map(f,[1,2,3,4])             #
 print(list(b))                 #
 #------------------------------#

'''
ilter，map和reduce
1)filter(bool_func,seq)：此函数的功能相当于过滤器。调用一个布尔函数bool_func
  来迭代遍历每个seq中的元素；返回一个使bool_seq返回值为true的元素的序列。
2)map(func,seq1[,seq2...])：将函数func作用于给定序列的每个元素，并用一个列表来提
  供返回值；如果func为None，func表现为身份函数，返回一个含有每个序列中元素集合的n个元组的列表。
3)reduce(func,seq[,init])：func为二元函数，将func作用于seq序列的元素，每次携
 带一对（先前的结果以及下一个序列的元素），连续的将现有的结果和下一个值作用在获得的随
 后的结果上，最后减少我们的序列为一个单一的返回值：如果初始值init给定，第一个比较会是
 init和第一个序列元素而不是序列的头两个元素。  
'''

 # 按规律提取列表中元素
 #------------------------------#
 def f(x):                      #
     if x%2==0:                 #
         return x               #
                                #
 b=map(f,[1,2,3,4])             #
 print('1')
 print(list(b))                 #
 #------------------------------#


 # 按规律提取列表中元素
 #------------------------------#
 def f(x):                      #
     if x%2==0:                 #
         return x               #
                                #
 b=filter(f,[1,2,3,4])          #
 print(list(b))                 #
 #------------------------------#
 -------------------------------------------------------------------------------------------------------------------- #

118.上传文件

 
 import requests

 with open('c.txt','rb') as f:
     requests.get('http://服务器 IP 地址：端口',data=f)
 # 接口测试之request上传文件
 url=''
 files=open('文件名')
 requests=requests.post(url,file=files)
 #使用匿名函数和列表生成式计算[1，2，3，4，5]元素乘积，并打印结果
 print(tuple(map(lambda x:x*x,[0,1,2,3,4,5])))
 print(tuple(x*x for x in [0,1,2,3,4,5]))

119.用reduce计算n阶阶乘

 
'''
educe() 函数会对参数序列中元素进行累积。
数将一个数据集合（链表，元组等）中的所有数据进行下列操作：用传给 reduce 中的函数 
unction（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数
用 function 函数运算，最后得到一个结果。
'''

 from functools import reduce
 print(reduce(lambda x,y:x*y,range(1,5)))
 筛选并打印输出100以内能被3整除的集合
 print(set(filter(lambda n:n%3==0,range(1,100))))

120.打印汉字拼音

from pypinyin import pinyin
print(pinyin('徐桂丽'))
print(pinyin('徐桂丽',heteronym=True))

# 用python发送短信
from twilio.rest import Client
# Your Account SID from twilio.com/console
account_sid = "替换成你的ACCOUNT_SID"
# Your Auth Token from twilio.com/console
auth_token  = "替换成你的auth_token"
client = Client(account_sid, auth_token)
message = client.messages.create(
    to="+8618740938964,替换成注册的手机号，也就是要接收短信的手机号，中国区是+86",
    from_="+15017250604，替换成你的twilio phone number，twilio分配给你的",
    body="Hello from Python Twilio!")
#$
import pymysql.connections
con=pymysql.connections.converters(user='roor',)

121.import numpy as np

 import numpy as np
 m=np.array([[1,2,3],[4,5,6]])
 print(m,'\n',type(m))

122.import tensorflow as tf

 import tensorflow as tf
 # 创建文件夹
 def mkdir(path):
     # 引入模块
     import os

     # 去除首位空格
     path = path.strip()           # 去除首位空格
     # 去除尾部 \ 符号
     path = path.rstrip("\\")

     # 判断路径是否存在
     # 存在     True
     # 不存在   False
     isExists = os.path.exists(path)

     # 判断结果
     if not isExists:
         # 如果不存在则创建目录
         # 创建目录操作函数
         os.makedirs(path)

         print(path + ' 创建成功')
         return True
     else:
         # 如果目录存在则不创建，并提示目录已存在
         print(path + ' 目录已存在')
         return False

 # 定义要创建的目录
 mkpath = "C:\\Users\\Administrator\\PycharmProjects\\python进阶\\我的小宝贝\\1.txt"    # 我的小宝贝\\1.txt为文件夹名
 # 调用函数
 mkdir(mkpath)

123.判断是否是润4月

 
 def year_l(year):
     if (year%4)==0:
         if (year%100)==0:
             if (year%400)==0:
                 print("{0} 是闰年".format(year))
             else:
                 print("{0} 不是闰年".format(year))
         else:
             print("{0} 是闰年".format(year))
     print("{0} 不是闰年".format(year))

 year_l(2000)
 year_l(2011)

124.判断是否为质数

 def pd_num(num):
     if num>1:
         for i in range(2,num):
             if (num%i)==0:
                 print(num,'不是质数')
                 print('-->',i,'*',num//i,'是',num)
                 break
             else:
                 print(num,'是质数')
     else:
         print(num,'不是质数')

 pd_num(1)
 pd_num(4)
 pd_num(5)

125.获取一个字符串中某个字符的个数

 
 from collections import Counter
 s='abahhkjsajoijsao'
 c1=Counter(s)
 print(type(c1))
 print(dict(c1))
 print(Counter([2,3,4,552,2,2,1,3]))

126.获得一篇文章中各个字符出现次数，统计出现频率最高的前10个字符

 from collections import Counter
 c=Counter
 with open('c.txt',encoding='utf-8') as f:
     for line in f.readlines():
         words=line.split()
     c1=Counter(words)
     c.update(c1)

127.deque实现高效的插入和删除双向列表的作用

 from collections import deque
 d=deque([12,2,'hello',4])
 d.append('world')
 d.appendleft('hahaha')
 print(d)
 d.pop()
 d.popleft()
 print(d)
 d.extend(['a','b'])
 d.extendleft(['c','d'])
 print('d')
 d.rotate(-2)
 print(d)
 print(list(d))

128.default在字典键值不存在时返回默认值

 from collections import defaultdict
 dd=defaultdict(list)
 dd['key1']=100
 print(dd['key2'])
 dd2=defaultdict(lambda :'abc')
 print(dd2['kk'])


# ---------------------------------------------#
# ((people类->student类),speaker类)->sample类  #
# ---------------------------------------------#

 class people:
     # 基本属性
     name=''
     age=''
     # 私有属性
     _weight=0

     # 构造方法
     def __init__(self,n,a,w):
         self.name=n
         self.age=a
         self._weight=w

     def speak(self):
         print('%s 说：我 %d 岁。'%(self.name,self.age))

 class student(people):
     grade=''

     def __init__(self,n,a,w,g):
         # 调用父类的构造
         people.__init__(self,n,a,g)
         self.grade=g                               # ---------------------------------------------#
                                                    #  ((people类->student类),speaker类)->sample类  #
     # 覆写父类的方法                                 # ---------------------------------------------#
     def speak(self):
         print('%s说：我%d岁了，我在读%d年级'%(self.name,self.age,self.grade))

 # s=student('ken',10,60,3)
 # s.speak()

 class speaker():
     topic=''
     name=''

     def __init__(self,n,t):
         self.name=n
         self.topic=t

     def speak(self):
         print("我叫%s，我是一个演说家，我演讲的主题是%s"%(self.name,self.topic))

 class sample(student,speaker):
     a=''
     def __init__(self,n,a,w,g,t):
         speaker.__init__(self, n, t)
         student.__init__(self,n,a,w,g)

 test=sample("Tim",25,80,4,"python")
 test.speak()       # 方法名相同，默认调用的是在括号中排在前的父类的方法
 print(dir(test))
 print(vars(test))

129.读入数据

data = pd.read_csv(
    'https://labfile.oss.aliyuncs.com/courses/1283/adult.data.csv')
print(data.head())

130.Python 函数参数前面一个星号（*）和两个星号（**）的区别

单星号（*）：*agrs
将所有参数以元组(tuple)的形式导入：

def foo(param1, *param2):
    print (param1)
    print (param2)
foo(1,2,3,4,5)
#1
#(2, 3, 4, 5)

双星号（**）：kwargs
双星号（）将参数以字典的形式导入:

def bar(param1, **param2):
    print (param1)
    print (param2)
bar(1,a=2,b=3)
#1
#{'a': 2, 'b': 3}

此外，单星号的另一个用法是解压参数列表：

def foo(runoob_1, runoob_2):
    print(runoob_1, runoob_2)
l = [1, 2]
foo(*l)
#1 2

当然这两个用法可以同时出现在一个函数中：

def foo(a, b=10, *args, **kwargs):
    print (a)
    print (b)
    print (args)
    print (kwargs)
foo(1, 2, 3, 4, e=5, f=6, g=7)
#1
##2
#(3, 4)
#{'e': 5, 'f': 6, 'g': 7}