注释的使用
#表示的是一个注释
print("hello world")
常见的数据类型
数字类型：
整数型int
print(10)
浮点型float
print(3.1415)
复数complex
print((-1)**0.5)
字符串类型
布尔型
列表型/数组型
['aa','bb']
字典类型
{'name':"lhh",'user':'秦始皇'}
元祖型
（1,2,3,552,3,4,5）
集合类型
{9,'hello',true,'good'}
查看数据类型
a = (-1)**0.5
b = 2**2
print(a,b)
print(type(a))
print(isinstance(c,str))
#Ture
不同进制数据的表示方式
a = 98 #十进制
b = 0b0101010101 #二进制
c = 0o23 #八进制
d = 0x1134 #十六进制
循环语句
import random
tempNum = int(input('请输入指定数字:'))
secret = random.randint(1, 10)
print(secret)
while tempNum != secret:
temp = int(input("猜错啦！请重新输入："))
if temp > secret:
print("太大啦")7
else:
if temp < secret:
print("太小啦")
if temp == secret:
print("恭喜你！猜对啦")
break
import random
secret = random.randint(1, 3)
a = 2
if secret == 1:
print('secret为1')
elif secret == 2:
print('secret为2')
else:
print('secret为3')
或且非
or and not
Pass关键字的使用
eg:可用来占位;pass 是一种空操作，解释器执行到它的时候，除了检查语法是否合法，什么也不做就直接跳过。
import random
secret = random.randint(1, 3)
a = int(input("请输入数字："))
if a == 1:
pass
print('secret为1')
假设法求质数
for i in range(2, 101):
flag = True
for j in range(2, int(i ** 0.5)):
if i % j == 0:
flag = False
break
if flag is True:
print(i, '是质数')
字符串
py = 'sjhjsdhahsj"sadhajsdajkshj"'
# print(py[2:])
# 字符串切片语法 m[start:end:step]
# step指的是步长，每隔step-1个截取一次
print(py[2:15:3])
获取字符串长度
x = 'sjasjdhajdhaskhdaj'
print(len(x))
查找字符串方法
find/rfind/index/findex
x = 'sjasjdhajdhaskhdaj'
print(x.find('j'))
print(x.index('j'))
print(x.rindex('j'))
print(x.rfind('j'))
in 和 not in
x = input("请输入内容：")
strContent = 'aa112277oopsksalsd'
if x not in strContent:
print("输入正确")
format 字符串拼接
a = '我是{name}'.format(name='李嘉诚')
# 什么都不写，会读取后面的内容，一一对应
b = '这里是{}{}{}'.format(1, 2, 3)
# 数字 可以根据索引来填充
c = '这里是{2}{2}{2}'.format('l', 'u', 'c', 'k', 'y')
# 混合使用数字和变量
d = '这里是{name}{1}{3}'.format('中国', '我', 1, '上海', name='李')
info = {'name': 'handsome', 'age': '10'}
h = '大家好，我是{name}'.format(**info)
字符串常用方法
列表(数组)常用方法
浅拷贝
import copy
a = [1, 2, 3, 4, 5, 6, 7, 8]
b = a.copy()
c = copy.copy(b)
print(c)
python常用系统模块
函数
def tellHandler():
a = int(input("请输入值："))
if (a > 10):
print("函数执行成功啦！")
else:
print("函数暂时未执行")
tellHandler()
函数的缺省函数
函数的可变参数
*arg表示可变位置参数
**arg表示可变的关键字参数
def callHandler(name, *bb, mul=10, kk=20, **arg):
ui = bb
print(name, mul, kk, '列表：', ui[1], arg['q'])
装饰器
import time
def caltime(fn):
def inner(x):
start = time.time()
s = fn(x)
end = time.time()
print("代码耗时", end-start, x)
return s
return inner
@caltime
def demo(n):
x = 0
for i in range(1, n):
x += i
return x
def calClk(fn):
def inner(x):
start = time.time()
# m = fn(x)
end = time.time()
print('时间', end-start,)
return 10
return inner
@calClk
def dearFn(n):
x = 0
for i in range(1, n):
x += i
print("dearFn{}值".format(x))
return 'dear'
kk = dearFn(100)
print(kk)
def add(fn):
def inner(game, name, time):
if (time > 60):
print("时间到了不能玩了")
else:
fn(game, name, time)
return inner
@add
def playHandler(game, name, time):
print('{game}在玩{name}用时{time}'.format(game=game, name=name, time=time))
playHandler('王者', '王宝强', 60)
# 装饰器的返回值在于装饰器函数内的返回值，如果原函数在装饰器内部函数中调用，原函数的返回值将在内置的函数中访问到
装饰器可变参数
def add(fn):
def inner(game, name, *args, **kwargs):
clock = kwargs['clock']
if (clock > 60):
print("时间到了不能玩了", clock)
else:
fn(game, name, clock)
return inner
@add
def playHandler(game, name, time):
print('{game}在玩{name}用时{time}'.format(game=game, name=name, time=time))
# playHandler('王者', '王宝强', clock=60)
# 装饰器的返回值在于装饰器函数内的返回值，如果原函数在装饰器内部函数中调用，原函数的返回值将在内置的函数中访问到
def callHandler(name, *bb, mul=10, kk=20, **arg):
ui = bb
print(name, mul, kk, '列表：', ui[1], arg['q'])
callHandler('kk', 1, 2, 3, 4, 5, q='bb')
模块
概念：一个py文件就可以理解为一个模块
python常见的系统模块
OS模块
sys模块
math模块
random模块
datetime模块
time模块
calendar模块
hashlib模块
hmac模块
copy模块
uuid模块
PIP命令
pip freeze
pip list
镜像
pip install <package_name> -i 从指定的地址下载包
name
直接运行python程序时，__name__的值为“__main__”
而在其它程序中导入.py文件运行时，__name__的值为文件名，即模块名
Python类
class person:
def __init__(self, name, age, height):
self.name = name
self.age = age
self.height = height
def clickHandler(self):
print("点击成功", self.name)
A = person('小红', 26, 170)
A.clickHandler()
__开始的是私有变量
class Person():
def __init__(self, name, age):
self.name = name
self.age = age
self.__moneny = 10000000000
def moreMoney(self):
print(self.__moneny)
def __getMoney():
print("千万富翁")
A = Person('小李', 27)
A.moreMoney()
python的魔术方法
slots
class person:
__slots__ = ('name', 'age', 'ui', 'height', 'test')
def __init__(self, name, age, height):
self.name = name
self.age = age
self.height = height
self.ui = age
def clickHandler(self):
print("点击成功", self.name)
A = person('小红', 26, 170)
A.test = 'test'
print(A.ui)
init
#在创建对象时会自动调用这个方法
class person:
__slots__ = ('name', 'age', 'ui', 'height', 'test')
def __init__(self, name, age, height):
self.name = name
self.age = age
self.height = height
self.ui = age
print("自动调用了吗")
def clickHandler(self):
print("点击成功", self.name)
____del
class person:
__slots__ = ('name', 'age', 'ui', 'height', 'test')
def __init__(self, name, age, height):
self.name = name
self.age = age
self.height = height
self.ui = age
print("自动调用了吗")
# 当对象销毁时，会调用这个方法
def __del__(self):
print("销毁时调用了")
def clickHandler(self):
print("点击成功", self.name)
str
repr
call
eq
setItem
可以在类中重写，如果不重写，比较的将是内存地址。
is
is身份运算符，可以判断两个对象是否是同一个对象
==会调用对象的__eq__方法，获取这个方法的比较结果
class person:
__slots__ = ('name', 'age', 'ui', 'height', 'test')
def __init__(self, name, age, height):
self.name = name
self.age = age
self.height = height
self.ui = age
print("自动调用了吗")
# 当对象销毁时，会调用这个方法
def __del__(self):
print("销毁时调用了")
def clickHandler(self):
print("点击成功", self.name)
A = person("a", 'A', 12)
B = person("a", 'A', 12)
C = [1, 2, 3]
D = [1, 2, 3]
print(A is B, C == D)
类的静态方法
class Person():
def __init__(self, name, age):
self.name = name
self.age = age
self.__moneny = 10000000000
def moreMoney(self):
print(self.__moneny)
def __getMoney():
print("千万富翁")
@staticmethod
def clickHandler():
print("静态方法打印成功")
Person.clickHandler()
类的继承
#传入object指继承自object
#python3以后，默认继承自object
class
class Animal(object):
def __init__(self, name):
self.name = name
print(self.name)
def sleep(self):
print("动物都会睡觉")
class Person(Animal):
def thinkAbout(self):
print("人类会思考")
A = Person('name')
A.sleep()
经典类和老式类
1、新式类：继承自Object的类，我们称之为新式类
2、经典类：不继承自Object的类
# 新式类和老式类
class Student(object):
pass
class Dog:
pass
isinstance
判断一个对象是否是由指定的类实例化出来的
#判断一个对象是否是由指定的类实例化出来的
class Student(object):
pass
class Dog:
pass
A = Student()
print(isinstance(A, Student))
子类重写父类方法
多态
# 多态是基于继承，通过子类重写父类的方法
# 达到不同的子类对象调用相同的父类方法，得到不同的结果。
# 提高代码的灵活度
# 子类重写父类方法
class Person(object):
def __init__(self, name, age):
self.name = name
self.age = age
def study(self):
print("好好学习，天天向上")
def schoolHandler(self):
print('{name}去上学啦'.format(name=self.name))
class Student(Person):
def __init__(self, name, age, school):
# 1.父类名.方法名(self,参数列表)
# Person.__init__(self, name, age)
self.school = school
# 2.使用super直接调用父类的方法
super().__init__(name, age)
def schoolHandler(self):
print("重写父类方法")
return super().schoolHandler()
P = Student('小杨', 22, '北大')
P.schoolHandler()
多态的使用
class Dog(object):
def work(self):
print('狗正在工作')
class PoliceDog(Dog):
pass
class Person(object):
def __init__(self, name):
self.name = name
newP = Person(Dog)
newP.name.work('name')
文件操作
场景：python代码操作，写入数据，只存在于内存当中。永久保存数据可以选择存在系统硬盘的文件当中。
open
参数介绍：
- file:用来指定打开的文件(不是文件的名字，而是文件的路径)
- mode:打开文件时的模式，默认 r 表示只读 ,w是写入模式，打开文件以后，只能写入，不能读取。如果文件存在，会覆盖文件。 rb 读取写入的结果是二进制 ，r+：可读写 w+:可读写
- encoding :打开文件时的编码方式
读取文件内容
print(open('./1.txt', encoding='utf8').read())
写入文件内容
普通方式写入
file = open('./1.txt', 'w', encoding='utf8')
file.write('我是霸道总裁',)
二进制方式写入（操作非文本文件）
file = open('./1.txt', 'wb')
file.write('我是霸道总裁啦'.encode('utf8'))
路径
1、绝对路径：从电脑盘符开始的路径
2、相对路径：
file.read()
讲所有文件都读取出来
file.readline()
只读取一行数据
file.readlines()
读取所有行的数据，保存在一个列表里
文件的拷贝
新文件名拼接
rpartition
os.path.splitext
import os
file_name = input('请输入一个文件路径：')
if os.path.isfile(file_name):
old_file = open(file_name, encoding='utf8')
names = file_name.rpartition('.')
new_file_name = names[0]+'_new'+names[2]
print(names, new_file_name)
else:
print('您输入的文件不存在')
将数据写入内存
StringIO
from io import StringIO
s_io = StringIO()
print('GOOD', file=s_io)
print(s_io.getvalue())
BytesIO
from io import BytesIO
b_io = BytesIO()
b_io.write('你好'.encode('utf8'))
print(b_io.getvalue().decode('utf8'))
标准输入
stdout
会将用户输入的信息打印到指定的文件内
import sys
# sys.stdin 接收用户的输入，说白了就是读取键盘里输入的数据
# sys.stdout 标准输出
# sys.stderr 错误输出
sys.stdout = open('stdout.txt', 'w', encoding='utf8')
print("杨静杨智")
stderr
import sys
# sys.stdin 接收用户的输入，说白了就是读取键盘里输入的数据
# sys.stdout 标准输出
# sys.stderr 错误输出
sys.stdout = open('stdout.txt', 'w', encoding='utf8')
print("杨静杨智")
sys.stderr = open('stderr', 'w', encoding='utf8')
print(1/0)
Json字符串
对象转json
import json
# json里将数据持久有两个方法
# dumps:将数据转换成json字符串，不会将数据爆粗难道文件里。
# dump:将数据转换成json字符串的同时写入到指定文件
names = ['qqes', 'ddfd']
file = open('names.txt', 'w', encoding='utf8')
json.dump(names, file)
file.close()
json转对象
import json
# json里将数据持久有两个方法
# loads:将json字符串转换成数据，不会将数据保存在文件里。
# load:将数据转换成json字符串的同时写入到指定文件
x = '{"name":"zhangsan"}'
p = json.loads(x)
print(p['name'])
数据转二进制
- 序列化 dumps：将python数据转换成为二进制
- dump:将python数据转换成为二进制，同时保存到指定的文件
- 反序列化 loads:将二进制加载成为python数据
- load:读取文件，并将文件的内容加载成为二进制
# json:将python里的数据（str/list/tuple/dict/int/float/bool/None）等转换成对应的json
# pickle:将python里的任意的对象转换成为二进制
import pickle
names = ["战三", "lisi1"]
b_names = pickle.dumps(names)
print(b_names)
# 序列化 dumps：将python数据转换成为二进制
# dump:将python数据转换成为二进制，同时保存到指定的文件
# 反序列化 loads:将二进制加载成为python数据
# load:读取文件，并将文件的内容加载成为二进制
pickle和json的区别
pickle用来讲数据原封不动的转换成为二进制
但是这个二进制只能在python里识别
json只能保存一部分信息，作用是用来在不同的平台里传递数据。
json里存储的数据都是基本的数据类型。
try … except
# try ... except 语句用来处理程序运行过程中的异常
try:
print(1/0)
file = open('names.txt')
print(file.read())
file.close()
except (FileNotFoundError, ZeroDivisionError) as e:
# 处理指定类型的异常
print("出错了", e)
finally
def demo(a, b):
try:
return a
finally:
return b
print(demo(1, 2))
# 如果函数里有finally,finally里的返回值会覆盖之前的返回值
with
try:
with open('name.txt', 'r', encoding='utf8') as file:
file.read() # 不需要在手动的关闭文件
except FileExistsError:
print("文件未找到")
# with我们称之为上下文管理器，很多需要手动关闭的连接
# 比如说文件连接，socket连接，数据库的连接，都能使用with自动关闭连接
# with关键字后面对象，需要实现__enter__和__exit__魔法方法
自定义异常
# 自定义异常
class LengthError(Exception):
def __intt__(self, x, y):
self.x = x
self.y = y
def __str__(self):
return "长度必须要在{}至{}之间".format(self.x, self.y)
password = input("请输入您的密码：")
m = 6
n = 12
if m <= len(password) <= n:
print("密码正确")
else:
raise LengthError
高级装饰器
def handleAction(a):
print(a)
def inner(fn):
def hannder(name, age):
print(name, age)
return hannder
return inner
@handleAction('aa')
def playGAME():
print("玩游戏", )
playGAME('aa', 'bb')
可迭代对象
# 可迭代对象：list/tuple/dict/set/str/range/filter/map
# 只要重写了__iter__方法就是一个可迭代对象
from collections.abc import Iterable
class Demo(object):
def __init__(self, x):
self.x = x
def __iter__(self):
pass
d = Demo(100)
print(isinstance(d, Iterable))
# 可迭代对象：list/tuple/dict/set/str/range/filter/map
# 只要重写了__iter__方法就是一个可迭代对象
from collections.abc import Iterable
class Foo(object):
def __next__(self):
return 1
class Demo(object):
def __init__(self, x):
self.x = x
def __iter__(self):
f = Foo()
return f
pass
d = Demo(100)
print(isinstance(d, Iterable))
# for in循环的本质就是调用可迭代对象的__iner__方法，获取到这个方法的返回值
# 这个返回值需要的是一个对象，然后再调用这个对象的__next__方法
1031
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
