Python语言

注释

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

判断语句

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

循环

while循环

i = 0
    while 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 = 30

print(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 = 30

print(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_name
        self.age = new_age

    def __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 = gailun

print("%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 = None

    def __new__(cls, name):
        # 如果类属性__instance的值为None，
        # 那么就创建一个对象，并且赋值__instance为这个对象的引用，保证下次调用这个方法时
        # 能够知道之前已经创建过对象了，这样就保证了只有1个对象
        if not cls.__instance:
            print('创建一个新对象')
            cls.__instance = object.__new__(cls)
        return cls.__instance


kangx01 = 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 = 0
        b = 1 / a
    finally:
        f.close()
        print('关闭文件')
except:
    print("没有这个文件")

# 完整结构
try:
  ...
except:
  ...
finally:
  ...
else:
  ...