python 笔记
变量和类型
整型 :二进制-- ob100(十进制4) 八进制-- 0o100(十进制64) 十六进制 --0x100(十进制256)
浮点型 : 123.456(数学法)= 1.23456e2(科学计数法)
字符串型 : 'hello' "hello"
布尔型 : True False
复数型 : 3+4j
运算符
[] [:] 下标切片 **指数 ~ 按位取反 + - * / %取模 //整除 >> << & ^按位异或 \|按位或
<= < > >= == !=
is is not 身份运算符
in not in 成员运算符
not or and 逻辑运算符
类型转换(非函数)
int():将一个数值或字符串转换成整数,可以指定进制
float():将一个字符串转换成浮点数
str():将指定的对象转换成字符串形式,可以指定编码
chr():将整数转换成该编码对应的字符串(一个字符)
ord():将字符串(一个字符)转换成对应的编码(整数)
分支结构
if语句的使用, 代码块依靠缩进即可
if ... :
#code
#code
elif ... :
#code
#code
else ... :
#code
#code
循环结构
1、for-in循环
明确的知道循环执行的次数或者对一个容器进行迭代
for x in range(1,101):
#code
range(101)可以产生一个0到100的整数序列。
range(1, 100)可以产生一个1到99的整数序列。
range(1, 100, 2)可以产生一个1到99的奇数序列,其中的2是步长,即数值序列的增量。
2、while循环
不知道具体循环次数的循环结构
while True:
#code
break
函数
重复出现和相对独立的功能生成函数
关键字def, return返回一个值
def xxx(arg):
#code
#code
return x
函数参数
可有默认值: def func(n=2):
可用可变参数: def func(*arg):
def add(*args):
total = 0
for val in args:
total += val
return total
print(add())
print(add(1))
print(add(1, 2))
print(add(1, 2, 3))
print(add(1, 3, 5, 7, 9))
基本输出函数print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
sep=' ' 各个值之间的分隔符
end='\n' 输出完成后以什么结尾
file=sys.stdout 输出到标准输出设备
flush=False 是否立即输出(在写入文件时有用)
模块管理函数
同名函数:
1、在同一源文件会被后面函数覆盖
2、不同源文件可以导入使用
import module1 as m1
import module2 as m2
m1.foo()
m2.foo()
__main__:模块执行开始不执行模块其它代码
def main():
# Todo: Add your code here
pass
if __name__ == '__main__':
main()
变量作用域
def foo():
b = 'hello'
def bar(): # Python中可以在函数内部再定义函数
c = True
print(a)
print(b)
print(c)
bar()
# print(c) # NameError: name 'c' is not defined
if __name__ == '__main__':
a = 100
# print(b) # NameError: name 'b' is not defined
foo()
函数要修改全局变量a的值需加上 global a
字符串和常用数据结构
字符串:str1 = 'hello, world!'
列表:[] list1 = [1, 3, 5, 7, 100] 下标[],切片[:],排序sorted sort,
生成式语法生成列表:f = [x for x in range(1, 10)]
f = [x + y for x in 'ABCDE' for y in '1234567']
yield关键字将一个普通函数改造成生成器函数
def fib(n):
a, b = 0, 1
for _ in range(n):
a, b = b, a + b
yield a
def main():
for val in fib(20):
print(val)
if __name__ == '__main__':
main()
元组:() 与列表类似 元素不可修改 元组在创建时间和占用的空间上面都优于列表
集合:{} 跟数学上的集合是一致的,元素不能重复可以进行交集、并集、差集等运算
字典: 可变容器模型
dict = { key:value,key1:value1}
print(dict['key'])
面向对象编程基础
抽象类
class Student(object):
#__init__是一个特殊方法用于在创建对象时进行初始化操作
#通过这个方法我们可以为学生对象绑定name和age两个属性
def __init__(self, name, age):
self.name = name
self.age = age
def study(self, course_name):
print('%s正在学习%s.' % (self.name, course_name))
# PEP 8要求标识符的名字用全小写多个单词用下划线连接
# 但是部分程序员和公司更倾向于使用驼峰命名法(驼峰标识)
def watch_movie(self):
if self.age < 18:
print('%s只能观看《熊出没》.' % self.name)
else:
print('%s正在观看岛国爱情大电影.' % self.name)
def main():
# 创建学生对象并指定姓名和年龄
stu1 = Student('骆昊', 38)
# 给对象发study消息
stu1.study('Python程序设计')
# 给对象发watch_av消息
stu1.watch_movie()
stu2 = Student('王大锤', 15)
stu2.study('思想品德')
stu2.watch_movie()
if __name__ == '__main__':
main()
访问可见性:如果希望属性是私有的,在给属性命名时可以用两个下划线作为开头
class Test:
def __init__(self, foo):
self.__foo = foo
def __bar(self):
print(self.__foo)
print('__bar')
def main():
test = Test('hello')
# AttributeError: 'Test' object has no attribute '__bar'
test.__bar()
# AttributeError: 'Test' object has no attribute '__foo'
print(test.__foo)
if __name__ == "__main__":
main()
访问可见性:私有属性也可以得到访问,添加更换名字的规则
class Test:
def __init__(self, foo):
self.__foo = foo
def __bar(self):
print(self.__foo)
print('__bar')
def main():
test = Test('hello')
test._Test__bar() #如此
print(test._Test__foo)
if __name__ == "__main__":
main()
访问可见性:所以我们并不建议将属性设置为私有的,以单下划线开头来表示属性是受保护的
面向对象有三大支柱:封装、继承和多态
封装:隐藏细节提供接口
继承:子类继承父类的变量和方法
多态:重写父类的方法实现不用的功能
@property装饰器
以单下划线开头,通过这种方式来暗示属性是受保护的,不建议外界直接访问,
那么如果想访问属性可以通过属性的getter(访问器)和setter(修改器)方法进行对应的操作。
@property包装器来包装getter和setter方法,使得对属性的访问既安全又方便
class Person(object):
def __init__(self, name, age):
self._name = name
self._age = age
# 访问器 - getter方法
@property
def name(self):
return self._name
# 访问器 - getter方法
@property
def age(self):
return self._age
# 修改器 - setter方法
@age.setter
def age(self, age):
self._age = age
def play(self):
if self._age <= 16:
print('%s正在玩飞行棋.' % self._name)
else:
print('%s正在玩斗地主.' % self._name)
def main():
person = Person('王大锤', 12)
person.play()
person.age = 22
person.play()
# person.name = '白元芳' # AttributeError: can't set attribute
if __name__ == '__main__':
main()
__slots__魔法
在类中定义__slots__变量来进行限定固定的变量
class Person(object):
# 限定Person对象只能绑定_name, _age和_gender属性
__slots__ = ('_name', '_age', '_gender')
def __init__(self, name, age):
self._name = name
self._age = age
@property
def name(self):
return self._name
@property
def age(self):
return self._age
@age.setter
def age(self, age):
self._age = age
def play(self):
if self._age <= 16:
print('%s正在玩飞行棋.' % self._name)
else:
print('%s正在玩斗地主.' % self._name)
def main():
person = Person('王大锤', 22)
person.play()
person._gender = '男'
# AttributeError: 'Person' object has no attribute '_is_gay'
# person._is_gay = True
静态方法和类方法
之前,我们在类中定义的方法都是对象方法,也就是说这些方法都是发送给对象的消息。
from math import sqrt
class Triangle(object):
def __init__(self, a, b, c):
self._a = a
self._b = b
self._c = c
@staticmethod
def is_valid(a, b, c):
return a + b > c and b + c > a and a + c > b
def perimeter(self):
return self._a + self._b + self._c
def area(self):
half = self.perimeter() / 2
return sqrt(half * (half - self._a) *
(half - self._b) * (half - self._c))
def main():
a, b, c = 3, 4, 5
# 静态方法和类方法都是通过给类发消息来调用的
if Triangle.is_valid(a, b, c):
t = Triangle(a, b, c)
print(t.perimeter())
# 也可以通过给类发消息来调用对象方法但是要传入接收消息的对象作为参数
# print(Triangle.perimeter(t))
print(t.area())
# print(Triangle.area(t))
else:
print('无法构成三角形.')
if __name__ == '__main__':
main()
和静态方法比较类似,Python还可以在类中定义类方法,类方法的第一个参数约定名为cls,
它代表的是当前类相关的信息的对象(类本身也是一个对象,有的地方也称之为类的元数据对象),
通过这个参数我们可以获取和类相关的信息并且可以创建出类的对象
from time import time, localtime, sleep
class Clock(object):
"""数字时钟"""
def __init__(self, hour=0, minute=0, second=0):
self._hour = hour
self._minute = minute
self._second = second
@classmethod
def now(cls):
ctime = localtime(time())
return cls(ctime.tm_hour, ctime.tm_min, ctime.tm_sec)
def run(self):
"""走字"""
self._second += 1
if self._second == 60:
self._second = 0
self._minute += 1
if self._minute == 60:
self._minute = 0
self._hour += 1
if self._hour == 24:
self._hour = 0
def show(self):
"""显示时间"""
return '%02d:%02d:%02d' % \
(self._hour, self._minute, self._second)
def main():
# 通过类方法创建对象并获取系统时间
clock = Clock.now()
while True:
print(clock.show())
sleep(1)
clock.run()
if __name__ == '__main__':
main()
继承:
class Person(object):
"""人"""
def __init__(self, name, age):
self._name = name
self._age = age
@property
def name(self):
return self._name
@property
def age(self):
return self._age
@age.setter
def age(self, age):
self._age = age
def play(self):
print('%s正在愉快的玩耍.' % self._name)
def watch_av(self):
if self._age >= 18:
print('%s正在观看爱情动作片.' % self._name)
else:
print('%s只能观看《熊出没》.' % self._name)
class Student(Person):
"""学生"""
def __init__(self, name, age, grade):
super().__init__(name, age)
self._grade = grade
@property
def grade(self):
return self._grade
@grade.setter
def grade(self, grade):
self._grade = grade
def study(self, course):
print('%s的%s正在学习%s.' % (self._grade, self._name, course))
class Teacher(Person):
"""老师"""
def __init__(self, name, age, title):
super().__init__(name, age)
self._title = title
@property
def title(self):
return self._title
@title.setter
def title(self, title):
self._title = title
def teach(self, course):
print('%s%s正在讲%s.' % (self._name, self._title, course))
def main():
stu = Student('王大锤', 15, '初三')
stu.study('数学')
stu.watch_av()
t = Teacher('骆昊', 38, '砖家')
t.teach('Python程序设计')
t.watch_av()
if __name__ == '__main__':
main()
多态:
from abc import ABCMeta, abstractmethod
class Pet(object, metaclass=ABCMeta):
"""宠物"""
def __init__(self, nickname):
self._nickname = nickname
@abstractmethod
def make_voice(self):
"""发出声音"""
pass
class Dog(Pet):
"""狗"""
def make_voice(self):
print('%s: 汪汪汪...' % self._nickname)
class Cat(Pet):
"""猫"""
def make_voice(self):
print('%s: 喵...喵...' % self._nickname)
def main():
pets = [Dog('旺财'), Cat('凯蒂'), Dog('大黄')]
for pet in pets:
pet.make_voice()
if __name__ == '__main__':
main()