02列表元组字典、类型与对象

标签：效果   append   子列   car   diff   ice   插入   4.0   副本   

一．  列表

1.     概念

列表是任意对象组成的序列, 从0开始整数索引。

例：names = [“dave”,”mark”,”ann”,”phil”]。names[0]指的是“dave”。

2.    方法

1）添加新项到列表末尾：names.append(“paula”)

2）将一项插入到列表中：names.insert(2,”thomas”)

3) 使用切片运算符可以提取一个子列表或者对子列表重新赋值

l  b=names[0:2]         #返回[“dave”,”mark”]，包头不包尾

l  c=names[2:]          #返回[“thomas”,”ann”,”phil”]

l  names[1]=”jeff”            #将names中的第二项替换

l  names[0:2]=[‘dave’,’mark’,’jeff’]        

#将列表的头两项替换为右边的列表，相当于增加了3项

4）使用+可以连接列表：a=[1,2,3]+[4,5]    #[1,2,3,4,5]

5) 创建一个空列表

       names=[]

       names=list()

3.     对象

1） 可以包含任意种类的python对象，包括其他列表

2） 包括其他列表时要用多次索引：a[0][1]

4.     遍历

    list = [‘html‘, ‘js‘, ‘css‘, ‘python‘]

1)      方法1

    for i in list:

        print ("序号：%s   值：%s" % (list.index(i) + 1, i))

2)      方法2

    for i in range(len(list)):

        print ("序号：%s   值：%s" % (i + 1, list[i]))

3)      方法3

    for i, val in enumerate(list):

        print ("序号：%s   值：%s" % (i + 1, val))

设置遍历开始初始位置，只改变了起始序号：‘

    for i, val in enumerate(list, 2):

        print ("序号：%s   值：%s" % (i + 1, val))

4） 直接获取列表所有内容

print(list)

二．  元组

1.    概念

要创建简单的数据结构，可以使用元组将一组值打包到一个对象中。

stock=(‘GOOG’,100,490.1)         #圆括号可有可无

2.    定义特殊元组

1） 空元组 a=()

2） 一个元素的元组

b=(item,)

c=item,

3.    获取元组的值

1） 使用索引

2） 将元组解包为一组变量

nam,shares,prices=stock

4.    特点

1） 创建元组后不能修改它的内容（无法替换，删除，添加元素）

2） 列表更为灵活，但是占用内存，而元组是不可变的，所以不会占用额外的内存空间

三．  集合

1.    概念

1） 集合用于包含一组无序的对象，使用set函数来创建。

s=set([3,5,9,10])

t=set(“hello”)

2） 集合是无序的

3） 支持实现交（&）差（-）并（|）、对称差（^）操作

2.    方法

1） 使用add()/update()添加新项

add用于添加一项，upadte是多项

2） remove()删除

四．  字典

1.    概念

字典是一个关联数组或散列表，其中包含通过键key索引的对象。

stock={

“name”:”GOOG”,

“shares”:100,

“price”:490.1

}

2.    操作

1） 访问字典成员,用键索引运算符

name=stock[“name”]

2） 插入或修改

stock[“shares”]=75

stock[“date”]=”June 7,2019”

3)      创建空字典

prices={}

prices=dict()

4)      使用in运算符可以检验某国内容是不是字典成员

if “SOCX” in prices:

p=prices[“SOCX”]

   else :

              p=0.0

上边的语句等效于 p=prices.get(“SOCX”,0.0)

5） 字典合并update方法

stock.update(new_stock)如果存在重复的键值，则使用新的字典中的值

6） 字典的遍历，获取到的是key

for k in xiaoming_dict:

        print(“%s - %s” % (k,xiaoming_dict))

7） 字典的key只能是不可变类型的变量，列表和字典不可以

五．引用与复制

1.    引用

a=b，就会创建一个b的新引用

2.    浅复制

创建一个新对象，但它包含的是对原始对象中包含的项的引用

3.    深复制

创建一个新对象，并且递归地复制它包含的所有对象，可以使用copy.deepcopy()来实现。

c改变a不变

5．    复数

1）复数z的实部和虚部分别使用z.real和z.imag

2）z.conjugate()用于计算z的复共轭

六．浮点数

1）as_integer_ratio()将浮点数转换为表示分数的一对整数

2）is_integer()测试浮点数是否表示整数值

例：

x=1.23

y=4.0

print(x.as_integer_ratio())

print(y.is_integer())

七．序列类型

序列表示索引为非负整数的有序对象集合，包括字符串，列表，和元组。所有序列都支持迭代。

1）lens(s)    s中的元素数

2）min(s)    s中的最小值

3）Max(s)    s中的最大值

4）sum(s,[,initial])  s中各项的和

5）all(s)      检查s中所有项是否为true

6）any(s)     检查s中是否有某项是true；当所有值都是0/false/“”时，结果为false

八．集合类型

1．基本概念

1）集合是不同元素的无序集合。

2）集合不提供索引或切片操作，对象中不存在相关的键值。

3）放入集合的项是不可变的。

2. 分类

1）set可变集合

2）fozenset不可变集合

3. 方法

1）len(s)    返回s中的项数

2) s.copy()   制作s的一份副本

3）s.difference(t) 返回差集

4）s.intersection(t) 返回交集

5）s.isdisjoint(t)  如果s与t没有相同项，则返回true

6）s.issubject(t)  如果s是t的一个子集, 则返回true

7) s.issuperset(t) 如果s是t的一个超集, 则返回true

8）s.symmetric_difference(t)  求对称差集

可变集合还有一些另外的方法

1）s.add(item)

2) s.clear() 删除s中所有的项

3）s.difference_update(t) 从s中删除同时也在t中的项

4）s.discard(item)删除项，如果项不存在，则没有效果

5）s.intersection_update(t)计算s与t的交集，并将结果放入s中

6）s.pop()返回一个任意的集合元素，并将其从s中删除

7）s.remove(item)从s中删除item，如果item不是s的成员，会引发KeyError异常

8）s. s.symmetric_difference_update(t) 计算s与t的对称差集，并将结果放入s中

9）s.update(t) 将t所有项添加到s中

02列表元组字典、类型与对象

标签：效果   append   子列   car   diff   ice   插入   4.0   副本   

原文地址：https://www.cnblogs.com/yaopeiyun/p/10324292.html