Python语言用法总结

python语言

注释
判断语句
循环
字符串操作
列表字典操作
函数
- 匿名函数
文件操作
面向对象
- - 类方法
  - 静态方法
- __new__方法
- 单例模式
异常
- 捕获异常

注释

单行注释  ： #
多行注释  ：""" """

判断语句

if加elseif 条件:满足条件时要做的事情1满足条件时要做的事情2满足条件时要做的事情3...(省略)...else:不满足条件时要做的事情1不满足条件时要做的事情2不满足条件时要做的事情3...(省略)...
if加elifif xxx1:事情1elif xxx2:事情2elif xxx3:事情3

循环

while循环

i = 0while i < 5:print("当前是第%d次执行循环" % (i + 1))print("i=%d" % i)i+=1

for循环

for iterating_var in sequence:statements(s)

字符串操作

列表字典操作

函数

匿名函数

range（）函数

range(start, stop[, step])start: 计数从 start 开始。默认是从 0 开始
stop: 计数到 stop 结束，但不包括 stop
step：步长，默认为1

列表推导式

a = [x for x in range(1,101)]
[1,2,3,...,100]

文件操作

说明：
r 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
w 打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
a 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
rb 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
wb 以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
ab 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
r+ 打开一个文件用于读写。文件指针将会放在文件的开头。
w+ 打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
a+ 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
rb+ 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
wb+ 以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
ab+ 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

#打开文件
f = open('test.txt', 'w')
#关闭文件
f.close()

面向对象

定义类

class 类名:属性方法#demo
class Cat:# 属性# 方法def eat(self):print('吃鱼')def drink(self):print('喝酸奶')

创建对象

#demo
class Hero(object):  # 新式类定义形式"""info 是一个实例方法，类对象可以调用实例方法，实例方法的第一个参数一定是self"""def info(self):"""当对象调用实例方法时，Python会自动将对象本身的引用做为参数，传递到实例方法的第一个参数self里"""print(self) print("self各不同，对象是出处。")# Hero这个类 实例化了一个对象  taidamier(泰达米尔)
taidamier = Hero()# 对象调用实例方法info()，执行info()里的代码
# . 表示选择属性或者方法
taidamier.info()print(taidamier)  # 打印对象，则默认打印对象在内存的地址，结果等同于info里的print(self)
print(id(taidamier))  # id(taidamier) 则是内存地址的十进制形式表示

获取对象属性

class Cat:# 属性# 方法def eat(self):print('吃鱼')def drink(self):print('喝酸奶')tom = Cat()
tom.eat()
tom.drink()tom.name = '汤姆'
tom.age = 30print(tom.name)
print(tom.age)

魔法方法：

# init方法
class Cat:# 属性def __init__(self):print('------init--------')self.name = 'tom'self.age = 20# 方法def eat(self):print('吃鱼')def drink(self):print('喝酸奶')def introduce(self):print('大家好，我是%s，我今年%s岁' % (self.name, self.age))print('创建tom前')
tom = Cat('汤姆', 30)
print('创建tom后')
tom.eat()
tom.drink()# tom.name = '汤姆'
# tom.age = 30print(tom.name)
print(tom.age)
tom.introduce()garfield = Cat('加菲猫', 31)
garfield.eat()
garfield.drink()# garfield.name = '加菲猫'
# garfield.age = 31
garfield.introduce()print(tom)
print(id(tom))
print(garfield)#str方法
class Cat:# 属性def __init__(self, new_name, new_age):print('------init--------')self.name = new_nameself.age = new_agedef __str__(self):print('名字%s----年龄：%s' % (self.name, self.age))# 方法def eat(self):print('吃鱼')def drink(self):print('喝酸奶')def introduce(self):print('大家好，我是%s，我今年%s岁' % (self.name, self.age))tom = Cat('汤姆', 30)# print(tom)  # 如果没有用__str__方法，就打印对象地址 16进制 <__main__.Cat object at 0x000001F921D88A58>print(id(tom))  # 打印对象地址 10进制print(tom) #如果写了__str__方法，就打印方法的返回内容 名字汤姆----年龄：30#del方法
class Hero(object):# 初始化方法# 创建完对象后会自动被调用def __init__(self, name):print('__init__方法被调用')self.name = name# 当对象被删除时，会自动被调用def __del__(self):print("__del__方法被调用")print("%s 被 GM 干掉了..." % self.name)# 创建对象
taidamier = Hero("泰达米尔")# 删除对象
print("%d 被删除1次" % id(taidamier))
del(taidamier)print("--" * 10)gailun = Hero("盖伦")
gailun1 = gailun
gailun2 = gailunprint("%d 被删除1次" % id(gailun))
del(gailun)print("%d 被删除1次" % id(gailun1))
del(gailun1)print("%d 被删除1次" % id(gailun2))
del(gailun2)

私有属性

class Person:def __init__(self):# 私有属性self.__name = '天下第一大帅锅'def my_name(self, password):if password == password:#  私有属性，可以在类的内部使用print(self.__name)else:print('不告诉你')person = Person()
# print(person.__name) # 私有属性无发使用person.my_name(123456) # 通过调用方法来使用到私用属性

私有方法

class Person:def __process_bug(self):print('专业处理程序bug')def process_bug(self, money):if money > 100:self.__process_bug()else:print('hehe')person = Person()
# print(person.__process_bug)
print(person.process_bug(200))

单继承，子类添加新方法

# 定义一个Master类      master精通， 大师的意思
class Master:def __init__(self):print('---Master--init---')def yyz(self):print("发出一招-----一阳指")# 定义Prentice类，继承了 Master
class Apprentice(Master):def tzst(self):print("发出一招-----弹指神通")wukong = Apprentice()
wukong.yyz()
wukong.tzst()

多继承

# 定义一个Master类      master精通， 大师的意思class Master:def __init__(self):self.name = '少林派'print('---Master--init---')def yyz(self):print("发出一招-----一阳指")# celestial [səˈlestʃl] 神仙，仙人
class Celestial:def __init__(self):# 属性self.name = "龟仙派"# 实例方法def qigong(self):print("发出一招...龟派气功")# 定义Prentice类，继承了 Master
class Apprentice(Master, Celestial):def rlsz(self):print("发出一招-----如来神掌")wukong = Apprentice()
wukong.yyz()
wukong.qigong()
wukong.rlsz()

多层继承，子类重写父类同名方法

# 定义一个Master类      master精通， 大师的意思
class Master:def __init__(self):print('---Master--init---')def yyz(self):print("发出一招-----一阳指")# 定义Prentice类，继承了 Master
class Apprentice(Master):def tzst(self):print("发出一招-----弹指神通")# 定义ApprenticeApprentice类，继承了 Apprentice
class ApprenticeApprentice(Apprentice):def yyz(self):print("发出一招-----一阳指--欧布增强版")def tzst(self):print("发出一招-----弹指神通--欧布增强版")# 实例化ApprenticeApprentice对象 给oubu
oubu = ApprenticeApprentice()
oubu.yyz()
oubu.tzst()

私有属性和方法能否继承

# 定义一个Master类      master精通， 大师的意思
class Master:def __init__(self):self.__name = '哈哈派'print('---Master--init---')def yyz(self):print("发出一招-----一阳指")def __khbd(self):print('使用-葵花宝典')# 定义Prentice类，继承了 Master
class Apprentice(Master):def tzst(self):print("发出一招-----弹指神通")# 定义ApprenticeApprentice类，继承了 Apprentice
class ApprenticeApprentice(Apprentice):def say(self):print(super().__name)print(super().__khbd())# 实例化ApprenticeApprentice对象 给oubu
oubu = ApprenticeApprentice()# print(oubu.__name) #报错
# print(oubu.__khbd()) #报错
oubu.say() # 报错

结论：私有方法和私有属性无法被继承

类属性&实例属性

# 类属性
class People(object):name = 'Tom'  # 公有的类属性__age = 12  # 私有的类属性p = People()print(p.name)  # 正确
print(People.name)  # 正确
print(p.__age)  # 错误，不能在类外通过实例对象访问私有的类属性
print(People.__age) # 错误，不能在类外通过类对象访问私有的类属性# 实例属性
class People(object):address = '山东'  # 类属性def __init__(self):self.name = 'xiaowang'  # 实例属性self.age = 20  # 实例属性p = People()
p.age = 12  # 实例属性
print(p.address)  # 正确
print(p.name)  # 正确
print(p.age)  # 正确print(People.address)  # 正确
print(People.name)  # 错误
print(People.age)  # 错误

类方法

用修饰器@classmethod来标识

静态方法

用修饰器@staticmethod来进行修饰

new方法

class A(object):def __init__(self):print("这是 init 方法")def __new__(cls):print("这是 new 方法")return object.__new__(cls)a = A()

总结：
__new__至少要有一个参数cls，代表要实例化的类，此参数在实例化时由Python解释器自动提供

__new__必须要有返回值，返回实例化出来的实例，这点在自己实现__new__时要特别注意，可以return父类__new__出来的实例，或者直接是object的__new__出来的实例

__init__有一个参数self，就是这个__new__返回的实例，__init__在__new__的基础上可以完成一些其它初始化的动作，__init__不需要返回值

我们可以将类比作制造商，__new__方法就是前期的原材料购买环节，__init__方法就是在有原材料的基础上，加工，初始化商品环节

单例模式

# 实例化一个单例
class HuangD(object):__instance = Nonedef __new__(cls, name):# 如果类属性__instance的值为None，# 那么就创建一个对象，并且赋值__instance为这个对象的引用，保证下次调用这个方法时# 能够知道之前已经创建过对象了，这样就保证了只有1个对象if not cls.__instance:print('创建一个新对象')cls.__instance = object.__new__(cls)return cls.__instancekangx01 = HuangD("康熙")
kangx02 = HuangD("康熙")print(id(kangx01))
print(id(kangx02))kangx01.age = 20
print(kangx02.age)# 创建一个新对象
# 1934936015928
# 1934936015928
# 20

异常

捕获异常

try:print num
except IOError:print('产生错误了')# try嵌套中
try:f = open('test.txt')try:print('好好学习1')print('好好学习2')a = 0b = 1 / afinally:f.close()print('关闭文件')
except:print("没有这个文件")# 完整结构
try:...
except:...
finally:...
else:...