PYTHON 100days学习笔记007-2：python数据类型补充(2)

day007:python数据类型补充(2)

目录

• day007:python数据类型补充(2)
  • 1、Python3 元组
    • 1.1 访问元组
    • 1.2 删除元组
    • 1.3 元组运算符
    • 1.4 元组索引，截取
    • 1.5 元组内置函数
  • 2、python3 字典
    • 2.1 访问字典里的值
    • 2.2 修改字典
    • 2.3 删除字典元素
    • 2.4 字典键的特性
      • 2.4.1 不允许同一个键出现两次。
      • 2.4.2 键必须不可变
    • 2.5 字典内置函数&方法
  • 3、python3集合
    • 3.1 集合的基本操作
      • 3.1.1 添加元素
      • 3.1.2 移除元素
      • 3.1.3 计算集合元素个数
      • 3.1.4 清空集合
      • 3.1.5 判断元素在集合是否存在
    • 3.2 集合内置方法完整列表

对python数据类型的继续学习补充

参考列表

Python3 元组

Python3 字典

Python3 集合

1、Python3 元组

Python 的元组与列表类似，不同之处在于元组的元素不能修改。

元组使用小括号，列表使用方括号。

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

tup1 = ('Google', 'Runoob', 1997, 2000);
tup2 = (1, 2, 3, 4, 5 );
tup3 = "a", "b", "c", "d";   #  不需要括号也可以
type(tup3)
print(tup1)
print(tup2)
print(tup3)

('Google', 'Runoob', 1997, 2000)
(1, 2, 3, 4, 5)
('a', 'b', 'c', 'd')

创建空元组

tup1 = ();

元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用：

tup1 = (50)
type(tup1)

int

tup2 = (50, )
type(tup2)

tuple

元组与字符串类似，下标索引从0开始，可以进行截取，组合等。

1.1 访问元组

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:

tup1 = (12, 34.56);
tup2 = ('abc', 'xyz')

# 新创建一个元组
tup3 = tup1 + tup2
print(tup3)

# 以下修改元组元素操作是非法的。
# tup1[0] = 100

(12, 34.56, 'abc', 'xyz')

1.2 删除元组

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如下实例:

tup = ('Google', 'Runoob', 1997, 2000)

print (tup)
del tup;
print ("删除后的元组 tup : ")
print (tup)

('Google', 'Runoob', 1997, 2000)
删除后的元组 tup : 

---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

<ipython-input-14-90c8126ec165> in <module>()
      4 del tup;
      5 print ("删除后的元组 tup : ")
----> 6 print (tup)

NameError: name 'tup' is not defined

1.3 元组运算符

与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。

Python 表达式	结果	描述
len((1, 2, 3))	3	计算元素个数
(1, 2, 3) + (4, 5, 6)	(1, 2, 3, 4, 5, 6)	连接
('Hi!',) * 4	('Hi!', 'Hi!', 'Hi!', 'Hi!')	复制
3 in (1, 2, 3)	True	元素是否存在
for x in (1, 2, 3): print (x,)	1 2 3	迭代

1.4 元组索引，截取

因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元素，如下所示：

元组：

L = ('Google', 'Taobao', 'Runoob')

| Python 表达式 | 结果 | 描述 |

| L[2] | 'Runoob' | 读取第三个元素 |

| L[-2] | 'Taobao' | 反向读取；读取倒数第二个元素 |

| L[1:] | ('Taobao', 'Runoob') | 截取元素，从第二个开始后的所有元素。 |

运行实例如下：

L = ('Google', 'Taobao', 'Runoob')

print(L[2])
print(L[-2])
print(L[1:])

Runoob
Taobao
('Taobao', 'Runoob')

1.5 元组内置函数

Python元组包含了以下内置函数

序号	方法及描述
1	len(tuple) 计算元组元素个数。
2	max(tuple) 返回元组中元素最大值。
3	min(tuple) 返回元组中元素最小值。
4	tuple(seq) 将列表转换为元组。

2、python3 字典

字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式如下所示：

d = {key1 : value1, key2 : value2 }

键必须是唯一的，但值则不必。

值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。

一个简单的字典实例：

dict = {'alice': '2341', 'beth': '9102', 'cecli': '3258'}

dict = {'alice': '2341', 'beth': '9102', 'cecli': '3258'}
print(dict)

{'alice': '2341', 'beth': '9102', 'cecli': '3258'}

也可如此创建字典：

dict1 = {'abc': 456}
dict2 = {'abc': 123, 98.6: 37}
print(dict1)
print(dict2)

{'abc': 456}
{98.6: 37, 'abc': 123}

2.1 访问字典里的值

把相应的键放入到方括号中，如下实例:

dict = {'Name': 'noob', 'Age': 7, 'Class': 'Frist'}
print("dict['Name']:", dict['Name'])
print("dict['Age']:", dict['Age'])

dict['Name']: noob
dict['Age']: 7

如果用字典里没有的键访问数据，会输出错误如下：

实例

dict = {'Name': 'noob', 'Age': 7, 'Class': 'Frist'}
print("dict['Alice']:" ,dict['Alice'])

---------------------------------------------------------------------------

KeyError                                  Traceback (most recent call last)

<ipython-input-24-2c5b4a7a3d8f> in <module>()
      1 dict = {'Name': 'noob', 'Age': 7, 'Class': 'Frist'}
----> 2 print("dict['Alice']:" ,dict['Alice'])

KeyError: 'Alice'

2.2 修改字典

向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对如下实例:

实例

dict = {'Name': 'roob', 'Age': 7, 'Class': 'Frist'}

dict['Age'] = 8  # 更新Age
dict['School'] = "python教程" # 添加信息

print("dict['Age']: ", dict['Age'])
print("dict['School']: ", dict['School'])

dict['Age']:  8
dict['School']:  python教程

2.3 删除字典元素

能删单一的元素也能清空字典，清空只需一项操作。

显示删除一个字典用del命令，如下实例：

实例

dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}

del dict['Name']
dict.clear()
print(dict)

del dict

print(dict['Age'])

{}

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-30-5dd37156ae74> in <module>()
      7 del dict
      8
----> 9 print(dict['Age'])

TypeError: 'type' object is not subscriptable

注： del() 方法后面也会讨论。

2.4 字典键的特性

字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。

两个重要的点需要记住：

2.4.1 不允许同一个键出现两次。

创建时如果同一个键被赋值两次，后一个值会被记住，如下实例：

dict = {'Name': 'Runoob', 'Age': 7, 'Name': '小菜鸟'}

print("dict[Name]: ", dict['Name'])

dict[Name]:  小菜鸟

2.4.2 键必须不可变

所以可以用数字，字符串或元组充当，而用列表就不行，如下实例：

dict = {['Name']: 'Runoob', 'Age': 7}

print ("dict['Name']: ", dict['Name'])

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-33-783f74b00710> in <module>()
----> 1 dict = {['Name']: 'Runoob', 'Age': 7}
      2
      3 print ("dict['Name']: ", dict['Name'])

TypeError: unhashable type: 'list'

2.5 字典内置函数&方法

Python字典包含了以下内置函数：

序号	函数及描述	实例
1	len(dict)	计算字典元素个数，即键的总数。
2	str(dict)	输出字典，以可打印的字符串表示.
3	type(variable)	返回输入的变量类型，如果变量是字典就返回字典类型。

Python字典包含了以下内置方法：

序号	函数	描述
1	radiansdict.clear()	删除字典内所有元素
2	radiansdict.copy()	返回一个字典的浅复制
3	radiansdict.fromkeys()	创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
4	radiansdict.get(key, default=None)	返回指定键的值，如果值不在字典中返回default值
5	key in dict	如果键在字典dict里返回true，否则返回false
6	radiansdict.items()	以列表返回可遍历的(键, 值) 元组数组
7	radiansdict.keys()	返回一个迭代器，可以使用 list() 来转换为列表
8	radiansdict.setdefault(key, default=None)	和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
9	radiansdict.update(dict2)	把字典dict2的键/值对更新到dict里
10	radiansdict.values()	返回一个迭代器，可以使用 list() 来转换为列表
11	pop(key[,default])	删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值
12	popitem()	随机返回并删除字典中的一对键和值(一般删除末尾对)

3、python3集合

集合（set）是一个无序的不重复元素序列。

可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

创建格式：

parame = {value01,value02,...}
或者
set(value)

basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
print(basket)

if ('orange' in basket):
    print(1)
    if ('crabgrass' in basket):
        print(2)
    else:
        print(-2)
else:
    print(-1)

a = set('abracadabra')

b = set('alacazam')

print(a)
print(b)
print(a - b) # 集合a中包含而集合b中不包含的元素
print(a | b) # 集合a或b中包含的所有元素
print(a & b) # 集合a和b中都包含了的元素
print(a ^ b) # 不同时包含于a和b的元素

{'apple', 'banana', 'pear', 'orange'}
1
-2
{'r', 'c', 'a', 'b', 'd'}
{'m', 'c', 'a', 'z', 'l'}
{'b', 'd', 'r'}
{'m', 'c', 'd', 'b', 'z', 'l', 'a', 'r'}
{'c', 'a'}
{'m', 'd', 'b', 'z', 'l', 'r'}

类似列表推导式，同样集合支持集合推导式(Set comprehension)

a = {x for x in 'abracadabra' if x not in 'abc'}
print(a)

{'d', 'r'}

3.1 集合的基本操作

3.1.1 添加元素

语法格式如下：

s.add(x)

将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。

thisset = set(("Google", "Runoob", "Taobao"))
thisset.add('Facebook')
print(thisset)

{'Taobao', 'Runoob', 'Facebook', 'Google'}

还有一个方法，也可以添加元素，且参数可以是列表，元组，字典等，语法格式如下：

s.update(x)

x 可以有多个，用逗号分开。

实例

thisset = set(("Google", "Runoob", "Taobao"))

thisset.update(("orange",))

print(thisset)

thisset.update({1, 3})

print( thisset )

thisset.update([1, 4], [5, 6])

print( thisset )

{'Taobao', 'Runoob', 'Google', 'orange'}
{1, 'Runoob', 3, 'Google', 'Taobao', 'orange'}
{1, 'Runoob', 3, 'Google', 4, 5, 'Taobao', 6, 'orange'}

3.1.2 移除元素

语法格式如下：

`

s.remove( x )

`

将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。

thisset = set(("Google", "Runoob", "Taobao"))
thisset.remove("Taobao")
print(thisset)

thisset.remove("alibaba")
print(thisset)

{'Runoob', 'Google'}

---------------------------------------------------------------------------

KeyError                                  Traceback (most recent call last)

<ipython-input-3-72759893f328> in <module>()
      3 print(thisset)
      4
----> 5 thisset.remove("alibaba")
      6 print(thisset)

KeyError: 'alibaba'

我们也可以设置随机删除集合中的一个元素，语法格式如下：

s.pop()

实例

thisset = set(("Google", "Runoob", "Taobao", "Facebook"))

print(thisset)
x = thisset.pop()

print(x)
print(thisset)

{'Taobao', 'Runoob', 'Google', 'Facebook'}
Taobao
{'Runoob', 'Google', 'Facebook'}

多次执行测试结果都不一样。

然而在交互模式，pop 是删除集合的第一个元素（排序后的集合的第一个元素）。

3.1.3 计算集合元素个数

语法格式如下：

len(s)

计算集合 s 元素个数。

thisset = set(("Google", "Runoob", "Taobao"))

len(thisset)

3

3.1.4 清空集合

语法格式如下：

s.clear()

清空集合 s

thisset = set(("Google", "Runoob", "Taobao"))
thisset.clear()
print(thisset)

set()

3.1.5 判断元素在集合是否存在

语法格式如下：

x in s

判断x是否在s中，在返回True；否则返回False.

实例

thisset = set(("Google", "Runoob", "Taobao"))

x = ("Runoob" in thisset)

y = ("kuka" in thisset)

print(x, y)

True False

3.2 集合内置方法完整列表

方法	描述
add()	为集合添加元素
clear()	移除集合中的所有元素
copy()	拷贝一个集合
difference()	返回多个集合的差集
difference_update()	移除集合中的元素，该元素在指定的集合也存在。
discard()	删除集合中指定的元素
intersection()	返回集合的交集
intersection_update()	删除集合中的元素，该元素在指定的集合中不存在。
isdisjoint()	判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
issubset()	判断指定集合是否为该方法参数集合的子集。
issuperset()	判断该方法的参数集合是否为指定集合的子集
pop()	随机移除元素
remove()	移除指定元素
symmetric_difference()	返回两个集合中不重复的元素集合。
symmetric_difference_update()	移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
union()	返回两个集合的并集
update()	给集合添加元素

---

END


2019-5-22 15:55:26