文章目录
- 前言
- 1.多态
- 2.继承
- 3.qt开发引入库
- 4.类 静态 实例方法
- 5.私有属性 私有方法
- 6. python实现单例模式 一个类一个实例
- 7. python动态获取和设置类的属性和方法
- 8. 对学生成绩进行评级
- 9. 元类 用来创建类的东西 类是原类的实例
- 10. python魔法方法 给类增加魔力的方法
- 11. 对象中实现 只读属性 将对象私有化 通过公有方法提供一个读取数据的接口
- 12. OpenCV读图及显示
- 13. MySQL使用
- 14. 生成注释文件
- 15. 函数定义
- 15. 函数定义升级版
- 16. 写函数
- 17. 写函数升级版
- 18. 读函数
- 19. 数的转换
- 20. 集合运算
- 21. 字符串倒序排列
- 22. 列表计算
- 23. 列表生成式
- 24. 格式输出函数
- 25. 字符串操作
- 26. 字典操作
- 27. 字符转字典
- 28. 列表生成
- 29. 大小写转化
- 30. 斐波拉且数列
- 31. 打印星星
- 32.打印星星升级版
- 33.查看当前目录下的文件
- 34.查看当前目录下的文件升级版
- 35.生成随机数，写入到文件中
- 36.查看某个目录下的文件
- 37.打印九九乘法表
- 38.打印倒三角
- 39.os和sys，os与操作系统有关，sys与程序和解释器有关
- 40.pickle序列化和反序列化
- 41.pickle序列化和反序列化升级版
- 42.with打开文件自动带了异常处理
- 43.列出当前目录下所有文件和文件夹名
- 44.获取字符串中某个字符的个数
- 45.用python标准库实现输入某年某月某日，判断这一天是这一年的第几天
- 46.计算一个数的阶乘
- 47.使用json数据处理方式查找字符串
- 48.定义函数
- 49.lamda函数，匿名函数；def用来创建有名称的函数。
- 50.单下划线和双下划线的区别
- 51.字符串的倒序排列
- 52.字符串的倒序排列32.计算一个数的阶乘
- 53.随便编写
- 54.计算x的n次方
- 55.形参，实参问题
- 56.计算一个数的阶乘
- 56.计算a*a+b*b+c*c+ 定义函数不确定有多少参数时，可用*来表示多个参数
- 57.打印1-10的数字及每个数的平方
- 58.生成验证码
- 59.统计字符串中中英文出现的次数
- 60.python执行shell脚本返回结果
- 61.输出某个路径下所有文件和文件夹的路径
- 62.输出某个路径下及其目录下的所有文件路径
- 63.列出当前目录下所有目录及文件夹名
- 64.输出某个路径及其子目录下所有以html为后缀的文件
- 65.计算一个数的阶乘
- 66.生成100个数，然后写入文件
- 67.逐行读入utf-8编码的文件打印在屏幕上
- 68.删除文件
- 69.获取当前目录
- 70.修改当前目录
- 71.以相反顺序展示一个文件的内容
- 72.设置一个函数，返回给定文件的后缀名
- 73.返回给定文件的 名称和后缀名
- 74.返回给定文件的后缀名
- 75.生成随机数
- 76.可以使用随即提取字符的方式生成验证码
- 77.从指定序列中随机获取指定长度的片段
- 78.打乱一个排好序的list对象
- 79.生成验证码的两种方式
- 80.以函数为参数返回一个替换函数的可执行函数
- 81.类传入外部参数全靠构造函数
- 82.简单生成器
- 83.带有yield语句的生成器 return返回值时不保留当前信息，yield返回值时会保留当前信息
- 84. 简单的迭代器迭代器 有两个基本语法 iter()和next()可以使用collections模块判断一个对象是否是迭代器
- 86.isinstance和type检测某一变量是否是某一类型，某一实例是否属于某一类
- 87.浅拷贝、深拷贝、赋值
- 88.map函数，根据提供函数对指定序列进行映射，相当于一次性求解多个值
- 89.reduce函数,对参数序列中的元素进行积累
- 90.reduce函数,对参数序列中的元素进行积累 reduce(函数，[迭代序列])
- 91.filter函数，过滤函数 返回序列
- 92.enumerate函数，返回枚举对象函数,可迭代
- 93.zip函数，拉链函数 返回列表
- 94.hasattr()判断一个对象是否有name属性和方法
- 95.getattr()获取对象属性和方法
- 96.setattr()给对象属性进行赋值
- 97.正则表达式//也称为规则表达式81.match函数
- 98.search函数
- 99.findall函数
- 100.finditer函数
- 101.compile函数
- 102.sub函数 re.sub(正则表达式模式，替换字符串，要被查找替换的原字符串，模式匹配后要替换的最大次数)
- 103.re
- 104.split函数
- 106.其他 92.选择排序
- 107.插入排序
- 108.冒泡排序
- 109.归并排序
- 110.快速排序
- 111.希尔排序
- 112.基数排序
- 113.创建文档
- 114.给定一个有序表，输出要插入的值k所在索引
- 115.编写一个函数，实现数字或者字符的链接
- 116.编写一个函数，实现将IP地址转换为一个整数
- 117.判断一个字符串是否以特定字符结尾？
- 118.上传文件
- 119.用reduce计算n阶阶乘
- 120.打印汉字拼音
- 121.import numpy as np
- 122.import tensorflow as tf
- 123.判断是否是润4月
- 124.判断是否为质数
- 125.获取一个字符串中某个字符的个数
- 126.获得一篇文章中各个字符出现次数，统计出现频率最高的前10个字符
- 127.deque实现高效的插入和删除双向列表的作用
- 128.default在字典键值不存在时返回默认值
- 129.读入数据
- 130.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}
扫一扫
395
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
