一． 列表list，用方括号括起来[]
二． 元组truple，用圆括号括起来()
- list和tuple是Python内置的有序集合，一个可变，一个不可变。根据需要来选择使用它们。
- 如果元组只有一个元素，不能用(‘a’)来定义，要加逗号(‘a’,)，因为用(‘a’)的话，圆括号可以代表运算
- List是不可变的，表示里面的数字，字符串，boolean，null以及对象的指向不可变。但是对象的指向的内容是可变的。且没有append()和insert()方法
-
三． 条件判断
- if x:
print(“True”)
只要x为非空字符串，非零数字，非空list等就判断为true - input方法：命令窗输入的任何内容都是str类型，可以用内置函数int()来转换
四． 循环：对于需要遍历的对象包括列表list，元组truple，字符串str？，range类型数字序列，集合set，字典dict
- for x in Y：
- range类型转换为列表list，list(range())
五． 字典dict（大括号括起来的键值对，{}）,无下标，不能使用切片
例子d = {'Michael': 95, 'Bob': 75, 'Tracy': 85} - 增加元素
d['Adam'] = 67 - 删除元素
1） 先判断是否有这个key
① 'Thomas' in d
② d.get(‘Thomas’)返回None，但是交互界面不显示
③ d.get(‘Thomas’，-1)返回-1，则表示没有这个key
2） 然后用字典的pop(key)方法，d.pop(‘Bob)，或则用内置函数del d[‘Bob’] - 修改：d[‘Bob’]=11，直接赋值就行
- 查找：d[key]
- 字典是无序的，查询速度快，key是唯一的且不可变，经常用字符串来代表key
- 空字典alien_0={}
- 遍历键值对
- 可临时排序内置函数sorted()方法，只是对key临时排序，不管value，是可迭代的
- items()方法
a={'b':'xiao','a':'lei'}
b=a.items()
print(b)
print(b.class)
print(isinstance(b,list))
print(isinstance(b,tuple))
for i in b:
print(i)
print(type(i))
c=tuple(b)
print(c)
sorted(b)
for name in sorted(b):
print(name)
1） 返回的是一个dict_item类型，不是元组也不是列表dict_items([('a', 'xiao'), ('b', 'lei')]) 是可迭代的iterable，可使用内置函数sorted临时排序，各元组之间排序
1） dict_item类的每一个元素都是元组类型('a', 'xiao')和('b', 'lei')
2） 可将dict_item类变成list列表list(b) 即[('a', 'xiao'), ('b', 'lei')]和turple元组turple(b) 即(('a', 'xiao'), ('b', 'lei'))
转变成的list和turple的每个元素都是元组类型
3） 遍历键值对for key,value in a.items():
- keys()方法
a={'a':'xiao','b':'lei'}
b=a.keys()
print(b)
print(b.class)
print(isinstance(b,list))
print(isinstance(b,tuple))
for i in b:
print(i)
print(type(i))
c=tuple(b)
print(c)
d=list(b)
print(d)
sorted(b)
for name in sorted(b):
print(name)
2） 返回的是一个dict_keys类型，不是元组也不是列表dict_keys(['a', 'b'])，是可迭代的iterable，可使用内置函数sorted临时排序，各字符串之间排序
3） dict_keys类的每一个元素都是字符串类型
4） 可将dict_keys类变成list列表list(b) 即['a', 'b']和turple元组turple(b) 即('a', 'b')
转变成的list和turple的每个元素都是字符串类型
5） 遍历键for name in sorted(a.keys):
Print(name)
6）
- values()方法
a={'b':'xiao','c':'lei','a':'li'}
b=a.values()
print(b)
print(b.class)
print(isinstance(b,list))
print(isinstance(b,tuple))
for i in b:
print(i)
print(type(i))
c=tuple(b)
print(c)
sorted(b)
print(sorted(b))
for name in sorted(b):
print(name)
1） 返回的是一个dict_values类型，不是元组也不是列表dict_values(['xiao', 'lei', 'li'])，是可迭代的iterable，可使用内置函数sorted临时排序，各字符串之间排序.
2） dict_keys类的每一个元素都是字符串类型
3） 可将dict_keys类变成list列表list(b) 即['a', 'b']和turple元组turple(b) 即('a', 'b')
转变成的list和turple的每个元素都是字符串类型
4） 遍历值for name in sorted(a.values):
Print(name.title())//因为是每个元素是字符串类型
六． 集合set：无序的无重复元素的集合,用大括号，无下标，不能使用切片，每次顺序都不一样
例子s={‘a’,’b’,’c’}
1.将list转换成set，且去掉重复的元素
S=set(可迭代类型)，一个空集合set()，用圆括号，不用方阔号{}
-
增加key
1）s.add(key)
2）s.update(x):x可以是元素、列表、元组、字典（取的字典的key）、集合 - 删除key
s.remove(key) - 修改key，通过增加和删除来进行修改
- 查找key，没办法查找，可以用in
七． 函数
- 内置函数:见python标准库https://docs.python.org/zh-cn/3/library/
1） sorted()方法，返回的是一个list，零时排序
2） set()方法，返回的是一个集合set，参数是可迭代类型，包括字符串、列表、元组、字典（迭代字典的时候默认的是keys集合） - 定义函数：
1） 注释：三对双引号括起来，可以生成函数的文档注释 - 空函数:相当于占位符，没想好怎么写，可以让代码先运行起来
def nop():
pass - 函数可以返回多个值，其实返回的是一个truple
- 参数：
1） 位置参数：按顺序赋值
def describe_pet(animal_type,pet_name):
“””显示宠物的信息”””
Print(“\nI hava a ”+animal_type+”.”)
Print(pet_name)
def describe_pet(‘harry’,’hamster’)实参
2） 关键字参数：def describe_pet(pet_name=’hamster’,animal_type=’harry’)调用的时候，实参可以不按顺序来赋值，但是调用的时候每个实参必须赋值，键值对
3） 默认参数：定义的时候，形参默认参数
def describe_pet(animal_type,pet_name=’dog’):
‘””显示宠物的信息”””
Print(animal_type)
Print(pet_name)
① 必选参数在前，默认参数在后。
② 调用的时候，可以按位置参数顺序赋值，可以对默认参数赋值（更新的值），也可以不对默认参数赋值（默认的值）
③ 调用的时候，可以按关键字参数赋值，调用的时候需要对每个非默认参数赋值，如果要更新默认参数，要对默认参数进行关键字参数赋值
④ 默认参数必须放在必选参数的后面
⑤ 默认参数为空字符串时，可用于灵活判断。
3） 传递任意数量的实参:形参前面带号
def test(toppings):
print(toppings)
test('mu','geree','extra')
① 形参toppings中的号让Python创建一个名为toppings的空元组，相当于参数是个元组，还可以和位置参数混合使用def test(a,*toppings)
4） 传递任意数量的关键字实参：形参前面带两个星号
def build_profile(first,last,user_info):
"""创建一个字典，其中包含我们知道的有关用户的一切"""
profile={}
profile['first_name'] = first
profile['last_name'] = last
for key,value in user_info.items():
profile[key]=value
return profile
user_profile =build_profile('albert','einstein',location='princeton',field='physics')
print(user_profile)
① 形参user_info中的号让python创建一个名为user_info的空字典，相当于参数是个字典，可以和位置参数混合使用
5）
-
八． 切片L[0:3]，元组、列表、字符串可以使用切片。字典和集合不能使用
九． 可迭代的对象：判断是否可迭代
from collections import Iterable
print(isinstance({'a':'xiao','b':'lei'}.items(),Iterable))
十． While循环 - 与for循环的区别：while后面一般用于循环判断是否为空，只要x是非零数值、非空字符串、非空list，非空set，非空dict字典，就判断为True，否则为False。
-
十一． 不可变类型：数字、字符串、元组
十二． 模块 - 模块是扩展名为.py的文件，是文件
-
导入整个模块import test,不需要添加扩展名，可以使用test.py文件中所有的函数。调用模块中的函数的时候就可以使用模块名.函数名()来调用具体的一个函数
- 导入模块test.py中指定的函数，不是所有的函数
from 模块名(不要后缀) import 函数名。调用的时候直接使用函数名()来调用，不用写模块名。 - 导入的时候可以用as来给模块名和函数名取别名
十三． 生成器generator - 如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器：generator。
- g = (x * x for x in range(10))
- 生成器也是可迭代的对象，所以可以循环遍历for n in g:print(n)
- Yield关键字，任何一个带有yield关键字的函数都是一个生成器，
十四． 面向对象编程 - 创建类
class Dog():
"""一次模拟小狗的简单测试"""
def init(self,name,age):
"""初始化属性name和age"""
self.name=name
self.age=age
def sit(self):
"""模拟小狗被命令时蹲下"""
print(self.name.title()+" in now sitting")
def roll_over(self):
"""模拟小狗被命令时打滚"""
print(self.name.title())+" rolled over!"
my_dog=Dog(name='xiaolei',age=6)
my_dog.sit()
1） 关键字class
2） 类名首字母大写，不使用下划线，使用驼峰法
3） init方法是构造函数初始的方法，一定会有，如果没有重新定义的话，会自动添加
4） self与java里面的this差不多，表示当前实例对象
- 实例化
- 添加属性在init()方法里面添加，self.属性名=参数，也可以在类中定义，类中的每个属性必须都初始值
- 调用方法
- 私有属性，self.__name=name，不能被外部访问到
- 继承
1） 如果写构造方法init()，一定要调用父类的构造方法，先初始化父类的构造方法，再初始化本类的特有属性
super().init__()
2） 多态：对扩展开放，可以随意新增Animal子类。对修改封闭，不需要修改依赖Animal类型的run_twice(animal)等函数。调用的时候，只需要传入具体的子类实例就行。
class Animal():
def run(self):
print("Animal is running")
def run_twice(animal):
animal.run()
animal.run()
class Dog(Animal):
def run(self):
print("Dog is running")
def eat(self):
print("Eating meat")
run_twice(Dog())
3）
4）
-
导入类
1） 将类写在模块中
2） 导入单个类，from 模块名(不要后缀) import 类名，与导入单个函数一样。然后跟函数一样调用
3） 导入所有类，import 模块名(不要后缀)，与导入整个模块一样。然后跟函数一样调用，因为也是构造方法。只不过返回的是个对象，且对象里面还有很多方法可供使用。
import car
my_beetle=car.Car('volkswageen','beetle',2016)
print(my_beetle.get_descriptive_name())
十五． 文件读写
1． 文件路径
1） 相对路径，当前代码运行下的那个路径
2） 绝对路径，在windows系统或者linux系统中的文件路径
2． 读文件
1） 用with关键字，表示不再需要访问文件后将其关闭，关闭IO流。
2） With open()函数，第一个参数是要打开的文件名，第二个参数是读取模式(只读r，r+又读又写，w只写，w)
3） open()函数，返回的是这种有个read()方法的对象，再python中统称为file-like object 文件类对象。
4） read()函数，会一次性读取文件的所有的内容，如果文件有10个G，内存就爆了，适合小文件，所以大文件推荐使用read(size)
5） readline()函数，每一次读一行，占内存小，适合大文件，需要用while循环
f = open('test.py', 'r')
line = f.readline()
while line:
print(line, end="")
line = f.readline()
f.close()
6） readlines()函数，readlines()方法读取整个文件所有行，保存在一个列表(list)变量中，每行作为一个元素，但读取大文件会比较占内存，用for循环
f = open("a.txt")
lines = f.readlines()
print(type(lines))
for line in lines:
print line，
f.close()
3． 写文件
1） 读文件mode=’r’，是默认的
2） 写文件mode=’w’，是写入，会覆盖。
3） 附加到文件mode=’a’
4．
十六． 装饰器
- 我们要增强now()函数的功能，比如，在函数调用前后自动打印日志，但又不希望修改now()函数的定义，这种在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）。
- 如何编写
- def log(func):
def wrapper(*args, *kw):
print('call %s():' % func.name)
return func(args, **kw)
return wrapperbr/>@log
def now():
print("2015-3-15")
f = now
f()