python元组读取到列表_python列表，元组，字典，集合

一． 列表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/>@logdef now():

print("2015-3-15")

f = now

f()