经济学Python代码 经济学py是什么

Python里的变量 ---门牌

 

Python在使用变量之前无须定义它的类型，但是必须声明以及初始化该变量。

Python中给变量赋值就是声明，初始化变量(也就是创建一个相应数据类型的对象，而那些数据类型就是类)，变量的类型是取决于其储存的数据。（下面代码中的a变量，其类型类型随着赋值的类型不同而改变）

#type(a)返回a的数据类型
a=1
print(type(a),'整型')

a=1.1
print(type(a),'浮点型')

a=True
print(type(a),'布尔类型')

a=''
print(type(a),'字符串类型')

a=['床前明月光','地上鞋两双']
print(type(a),'列表')

a=(123,123)
print(type(a),'元组')

a={'好诗':'举头望明月，低头思故乡','好湿':'床前明月光，地上鞋两双'}
print(type(a),'字典')

a={12345,'上山打老虎'}
print(type(a),'集合')


# <class 'int'> 整型
# <class 'float'> 浮点型
# <class 'bool'> 布尔类型
# <class 'str'> 字符串类型
# <class 'list'> 列表
# <class 'tuple'> 元组
# <class 'dict'> 字典
# <class 'set'> 集合

 

数据类型

Python3 中常用的数据类型：

• 不可变数据类型
• Number（数字）
• String（字符串）
• Tuple（元组）
• 可变数据类型
• List（列表）
• Dictionary（字典）
• Sets（集合）

数据类型类型可分为：可变数据类型，不可变数据类型。

可变数据类型是指一个ID地址中储存的数据是可以改变的。

不可变数据类型是指一个ID地址中储存的数据不可以改变。

一 ，Number(数字)----不可变数据类型

1.int（整型）

int类型就是整数

Python的2.x的版本中还存在Long长整型（表示比较长的整数（比较大OR比较小）），3.x的版本中就只有int整型

整型类型能表达的数值仅仅与你的机器支持的（虚拟）内存大小有关，换句话说，Python能轻松表达很大的整数。

 

 

（嘿嘿，自己去算算对不对）

2.float（浮点数）

我们暂时的把浮点数理解为带小数点的小数（我还会开单章来说说浮点数）

浮点数随笔链接

3.bool（布尔类型）

把 True 和 False 定义成关键字了，但它们的值还是 1 和 0，它们可以和数字相加

 

注意：

• 1、Python可以同时为多个变量赋值，如a, b = 1, 2。
• 2、一个变量可以通过赋值指向不同类型的对象。
• 3、数值的除法 / 总是返回一个浮点数，要获取整数使用 // 操作符（ // 是以舍去小数部分来取整的）。
• 4、在混合计算时，Python会把整型转换成为浮点数。

Python还支持complex（复数），复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。

二，String（字符串）----不可变数据类型

字符串是以单引号 ' or双引号 " or三引号 ''' 括起来的任意文本（用来括起文本的单引号，双引号，三引号并不是文本里的字符），例如：'追求喜欢的女孩’,“有机会要追求”，‘’’没有机会，创造机会也要追求‘‘’

当有属于文本中的单引号  ’ ，就需要用双引号把文本括起来；当有属于文本中的双引号  "，就需要用三引号把文本括起来。（当引号为文本时要用引号多的把引号少的括起来）

 

三引号可以把多行字符串括起来

使用反斜杠 \ 转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串：

>>>print('L\ove')
L
ove
>>> print(r'L\ove')
L\ove
>>>

字符串的操作

[ ],[ : ],[ : : ]通过索引可以进行切片操作，和列表一样（在列表时会详细讲）

加号 (+) 是字符串的连接符， 星号 (*) 表示复制当前字符串，紧跟的数字为复制的次数。

str = 'I Love'
print((str+'You ')*4)

#输出 I LoveYou I LoveYou I LoveYou I LoveYou

注意

Python 没有单独的字符类型，一个字符就是长度为1的字符串。

与 C 字符串不同的是，Python 字符串不能被改变。向一个索引位置赋值，比如word[0] = ‘m’会导致错误。

三，tuple（元组）----不可变数据类型

元组被称为只读列表，即数据可以被查询，但不能被修改，所以，列表的切片操作同样适用于元组。

元组写在小括号 () 里，元素之间用逗号隔开。

 同一个元组中，元素可以是不同的（元素可以为任意类型）

虽然tuple的元素不可改变，但它的元素可以为可变数据类型，比如list列表。（现在不理解没关系，在后面解释可变与不可变数据类型中会有详细解释）

tup =([11,22,33], ['无边落木萧萧下', 44])
a=tup[1]
b=[11,22,33]
print(id(a))
print(id(tuple[1]))
print(id(b))
#输出结果
#31469064
#31469064
#31927176

构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：

tup1 = ()    # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号

作用：

1 对于一些数据我们不想被修改，可以使用元组；

2 另外，元组的意义还在于，元组可以在映射（和集合的成员）中当作键使用——而列表则不行；元组作为很多内建函数和方法的返回值存在。

四， List（列表）----可变数据类型

列表（list）是使用使用中括号 [ ] 来解析列表。

通过列表可以对数据实现最方便的存储、修改等操作

定义列表

a = ['锦','瑟','无','端','五','十','弦']  # 定义一个列表
a=list(('锦','瑟','无','端','五','十','弦'))#强制转换

 同一个列表中，元素可以是不同的（元素可以为任意类型）

通过下标访问列表中的元素，下标从0开始计数

 

 增（append，insert， extend）

 

1.insert 方法用于将对象插入到列表中

 

a = ['锦', '瑟', '无', '端', '五', '十', '弦']  # 定义一个列表
a.insert(0,'就是这')
print(a)
# ['就是这', '锦', '瑟', '无', '端', '五', '十', '弦']

 

2.append方法则用于在列表末尾追加新的对象

a = ['锦', '瑟', '无', '端', '五', '十', '弦']  # 定义一个列表
a.append('最后面')
print(a)
# ['锦', '瑟', '无', '端', '五', '十', '弦', '最后面']

3.追加一个序列里的多个元素( extend)

         extend 方法可以在列表的末尾一次性追加另一个序列（可迭代对象，如 列表，字典，元组，字符串）中的多个值。

　　  extend 方法修改了被扩展的列表，而原始的连接操作（+）则不然，它会返回一个全新的列表。

#列表
a = ['锦', '瑟', '无', '端', '五', '十', '弦']
b = ['一', '弦', '一', '柱', '思', '华', '年']
a.extend(b)  #只是对a进行扩展，无返回值（不会产生新的列表）
print(a)  # ['锦', '瑟', '无', '端', '五', '十', '弦', '一', '弦', '一', '柱', '思', '华', '年']
b.extend(b)
print(b)  # ['一', '弦', '一', '柱', '思', '华', '年', '一', '弦', '一', '柱', '思', '华', '年']　

#字典
a = ['一', '弦', '一', '柱', '思', '华', '年']
b = {'字典':123,'键':456}  # 可迭代对象是字典(默认是键)
a.extend(b)
print(a)  # ['一', '弦', '一', '柱', '思', '华', '年', '字典', '键']

#元组
a = ['一', '弦', '一', '柱', '思', '华', '年']
b=(1,2,3,4)
a.extend(b)
print(a)  # ['一', '弦', '一', '柱', '思', '华', '年', 1, 2, 3, 4]

#字符串
a = ['一', '弦', '一', '柱', '思', '华', '年']
b='abcd'
a.extend(b)
print(a)  # ['一', '弦', '一', '柱', '思', '华', '年', 'a', 'b', 'c', 'd']

 删（remove，del，pop）

1.remove删除以值指定的元素

a = ['锦', '瑟', '无', '端', '五', '十', '弦'] # 定义一个列表
a.remove('瑟')  # 删除元素'瑟'，当要删除的元素有多个相同时，删最前面那个（就是下标最小的那个，这个函数检索列表是从下标0开始的）
print(a)
# ['锦', '无', '端', '五', '十']

2.del删除以下标指定的元素or整个列表

a = ['锦', '瑟', '无', '端', '五', '十', '弦'] # 定义一个列表
del a[0]   # 删除以下标指定的元素
print(a)
# ['无', '端', '五', '十']
del a    # 删除整个列表

3.pop删除列表中指定下标元素，默认删除最后一个元素，并且返回该元素的值，如果列表为空或者索引值超出范围会报一个异常。

# a.pop([index=-1])
a = ['一', '弦', '一', '柱', '思', '华', '年'] # 定义一个列表
b=a.pop()   # 默认下标为-1  index=-1 删除最后一个元素  
print(b)  # a.pop()会返回被删除的元素
# 弦
print(a) # ['一', '弦', '一', '柱', '思', '华'] 
a.pop(0)
print(a) # ['弦', '一', '柱', '思', '华']

 改（重新赋值）

注意：列表可以重新赋值，元组不可以

a = ['锦', '瑟', '无', '端', '五', '十', '弦']  # 定义一个列表
a[0]=0
print(a)
# [0, '瑟', '无', '端', '五', '十', '弦']
a[1]='1'
print(a)
# [0, '1', '无', '端', '五', '十', '弦']
a[2:4]=2,3
print(a)
# [0, '1', 2, 3, '五', '十', '弦']
a[4::2]=4,7
print(a)
# [0, '1', 2, 3, 4, '十', 7]

 

查（切片，index）

1.切片操作（列表的切片，字符串，元组的切片操作都是一样的）

切片---取一个元素

a = ['锦','瑟','无','端','五','十','弦'] # 定义一个列表

>>> a[0]
'锦'
>>> a[6]
'弦'
>>> a[-1]
 '弦'
>>> a[-2] #还可以倒着取
 '十

 

得到的是一个新的列表）

a = ['锦', '瑟', '无', '端', '五', '十', '弦']  # 定义一个列表

# a[起始下标:结束下标:移动的方向和步幅]

b = a[0:6]
print(b)
# ['锦', '瑟', '无', '端', '五', '十']
# a[0:6]取头不取尾
b = a[0:]
print(b)
# ['锦', '瑟', '无', '端', '五', '十', '弦']
# a[0:]才可以去到尾
b = a[:]
print(b)
# ['锦', '瑟', '无', '端', '五', '十', '弦']
# b = a[:]从头取到尾

# 当a[::]的的二个 : 没有时，我们就默认其步幅为1。
# 步幅: 步幅为1时是“走一步“取一个。例如，'锦'走一步是'瑟'
#      步幅为2时时“走两步”取一个。例如，'锦'走两步是'无'
# 方向：步幅为正数时(顺着取)，是由左向右走；步幅为负数时(倒着取)，是由右向左走

b = a[0:6:2]
print(b)
# ['锦', '无', '五']
# 步幅为2
b = a[0:-1:2]
print(b)
# ['锦', '无', '五']
b = a[6:1:-1]
print(b)
# ['弦', '十', '五', '端', '无']
# 步幅为-2
b = a[-1:1:-2]
print(b)
# ['弦', '五', '无']

2.靠元素找下标 (index)

　　该方法可以避免遍历列表来找元素下标。

       Python 列表 index() 方法用于从列表中找出某个对象第一个匹配项的索引位置，如果这个对象不在列表中会报一个异常。

　　index() 方法语法：

a.index(value, start, stop)

    value-- 指定检索的对象。
    start -- 可选参数，开始索引，默认为0。（可单独指定）
    stop -- 可选参数，结束索引，默认为元祖的长度。（可单独指定）

a = ['一', '弦', '一', '柱', '思', '华', '年', '一', '弦', '一', '柱', '思', '华', '年']
b = a.index('一')
print(b)  # 0
b = a.index('一',1)
print(b)  # 2
b = a.index('弦',0,0)
print(b)
# b = a.index('弦',0,0)
# ValueError: '弦' is not in list

其他

1.统计( count)

某个元素在列表中出现的次数

a = ['锦', '瑟', '无', '端', '五', '十', '弦', '弦', '弦']  # 定义一个列表
b = a.count('弦')  # 统计'弦'在列表a中出现的次数
print(b)  # 3

2.翻转(reverse)

       reverse 方法将列表中的元素反向存放。

       该方法只是对列表操作，无返回值（不会产生新的列表）

a = ['一', '弦', '一', '柱', '思', '华', '年']
a.reverse()
print(a)  # ['年', '华', '思', '柱', '一', '弦', '一']

 3.复制（copy()）

因为列表的元素可以是可变和不可变数据类型，所以就涉及到了深浅复制

a=['锦', '瑟', '无', '端', '五', '十', '弦', '一', '弦', '一', '柱', '思', '华', '年']
b=a.copy()
print(b) # ['锦', '瑟', '无', '端', '五', '十', '弦', '一', '弦', '一', '柱', '思', '华', '年']

 

五，Dictionary（字典）----可变数据类型

 字典是python中唯一的映射类型，采用键值对（key-value）的形式存储数据。

python对key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无序存储的，且key必须是可哈希的。

可哈希表示key必须是不可变类型，如：数字、字符串、元组。

 

dic1={'name':'BarkingPig',(1,):[1,2,3],2:13}
dic2=dict((('name','BarkingPig'),((1,),[1,2,3]),(2,13)))

增（‘=’，setdefault()）

1.‘=’

dic = {1: '日照香炉生紫烟', 2: '遥看瀑布挂前川'}
dic[3] = '飞流直下三千尺'
print(dic)
#{1: '日照香炉生紫烟', 2: '遥看瀑布挂前川', 3: '飞流直下三千尺'}

2.添加查询键值对（setdefault()）

Python 字典 setdefault() 方法和 get() 方法类似,返回指定键的值，如果键不在字典中，将会添加键并将值设置为一个指定值，默认为None。

而 get() 不会添加键。

dic.setdefault(key[,default=None])

key -- 字典中要查找的键。
default -- 可选参数，如果指定键的值不存在时，返回该值，默认为 None

dic = {1: '日照香炉生紫烟', 2: '遥看瀑布挂前川'}
dic.setdefault(3)
dic.setdefault(4,'疑是银河落九天')
print(dic)
#{1: '日照香炉生紫烟', 2: '遥看瀑布挂前川', 3: None, 4: '疑是银河落九天'}

删（del,pop(),clear()，popitem()）

1.删除查询到的键值对or整个字典（del）

删除整个字典

dic = {1: '日照香炉生紫烟', 2: '遥看瀑布挂前川',3:'飞流直下三千尺',4:'疑是银河落九天'}
del dic
print(dic)
# NameError: name 'dic' is not defined

删除键对应键值对

dic = {1: '日照香炉生紫烟', 2: '遥看瀑布挂前川',3:'飞流直下三千尺',4:'疑是银河落九天'}
del dic[1]
print(dic)
# {2: '遥看瀑布挂前川', 3: '飞流直下三千尺', 4: '疑是银河落九天'}

2删除指定键值对（pop()）

pop() 方法删除给定键所对应的键/值对，并返回被删除的值。给定键如果不在字典中，则必须设置一个default值，否则会报错，此时返回的就是default值。

dic.pop(key[,default])

    key: 要删除的键/值对所对应的键
    default: 可选参数，给定键不在字典中时必须设置，否者会报错(没有默认值)，此时返回default值。

dic = {1: '日照香炉生紫烟', 2: '遥看瀑布挂前川',3:'飞流直下三千尺',4:'疑是银河落九天'}
a=dic.pop(4,True)
print(dic,a) # {1: '日照香炉生紫烟', 2: '遥看瀑布挂前川', 3: '飞流直下三千尺'} 疑是银河落九天
a=dic.pop(5,True)
print(dic,a) # {1: '日照香炉生紫烟', 2: '遥看瀑布挂前川', 3: '飞流直下三千尺'} True

3.置空（clear()）

clear() 方法用于删除字典内所有元素(就是把字典置空，不删除字典)。

dic = {1: '日照香炉生紫烟', 2: '遥看瀑布挂前川',3:'飞流直下三千尺',4:'疑是银河落九天'}
dic.clear()
print(dic) # {}

4..删除“最后一对键值对”（popitem()）

popitem() 方法随机返回并删除字典中的一个键/值对（一般删除末尾对）。

为什么是随机删除呢？因为字典是无序的，没有所谓的“最后一项”或是其它顺序。在工作时如果遇到需要逐一删除项的工作，用popitem()方法效率很高。

如果字典已经为空，却调用了此方法，就报出KeyError异常。

dic = {1: '日照香炉生紫烟', 2: '遥看瀑布挂前川',3:'飞流直下三千尺',4:'疑是银河落九天'}
a=dic.popitem()
print(dic,a) # {1: '日照香炉生紫烟', 2: '遥看瀑布挂前川', 3: '飞流直下三千尺'} (4, '疑是银河落九天')

 

改（‘=’，update()）

1.‘=’

dic = {1: '日照香炉生紫烟', 2: '遥看瀑布挂前川',3:'飞流直下三千尺',4:'疑是银河落九天'}
dic[1]='黄河之水天上来'
print(dic) #{1: '黄河之水天上来', 2: '遥看瀑布挂前川', 3: '飞流直下三千尺', 4: '疑是银河落九天'}

 

2.改，扩展（update()）

update() 方法用于更新字典中的键/值对，可以修改存在的键对应的值，也可以添加新的键/值对到字典中

dic= {1: '日照香炉生紫烟', 'two':'遥看瀑布挂前川' }
dic.update(two='黄河之水天上来')  # 修改键对应的值，键为数字时不适用
print(dic) # {1: '日照香炉生紫烟', 'two': '黄河之水天上来'}
dic1={3:'飞流直下三千尺',4:'疑是银河落九天'}
dic.update(dic1)  # 扩展字典
print(dic) # {1: '日照香炉生紫烟', 'two': '黄河之水天上来', 3: '飞流直下三千尺', 4: '疑是银河落九天'}

查（‘=’，get()，keys()，values()，items()，in/not in，sorted()）

1.‘=’

dic = {1: '日照香炉生紫烟', 2: '遥看瀑布挂前川', 3: '飞流直下三千尺', 4: '疑是银河落九天'}
a=dic[1]
print(a) # 日照香炉生紫烟

2.键找值（get()）

get() ,返回指定键的值，如果键不在字典中，返回一个指定值，默认为None。

dic = {1: '日照香炉生紫烟', 2: '遥看瀑布挂前川', 3: '飞流直下三千尺', 4: '疑是银河落九天'}
a=dic.get(1)
print(a) # 日照香炉生紫烟

3.所有键列表（keys()）

keys() 方法以列表形式（并非直接的列表，若要返回列表值还需调用list函数）返回字典中的所有的键。

dic = {1: '日照香炉生紫烟', 2: '遥看瀑布挂前川', 3: '飞流直下三千尺', 4: '疑是银河落九天'}
print(dic.keys()) # dict_keys([1, 2, 3, 4]) #并非直接的列表
a=list(dic.keys()) 
print(a)  # [1, 2, 3, 4]

4.所有值列表（values()）

values() 方法以列表形式（并非直接的列表，若要返回列表值还需调用list函数）返回字典中的所有值。

dic = {1: '日照香炉生紫烟', 2: '遥看瀑布挂前川', 3: '飞流直下三千尺', 4: '疑是银河落九天'}
print(dic.values()) # dict_values(['日照香炉生紫烟', '遥看瀑布挂前川', '飞流直下三千尺', '疑是银河落九天']) #并非直接的列表
a=list(dic.values())
print(a)  # ['日照香炉生紫烟', '遥看瀑布挂前川', '飞流直下三千尺', '疑是银河落九天']

 

5.所有键值对列表（items()）

items() 方法以列表形式（并非直接的列表，若要返回列表值还需调用list函数）返回所有的键值对（一对键值对构成的元组）

dic = {1: '日照香炉生紫烟', 2: '遥看瀑布挂前川', 3: '飞流直下三千尺', 4: '疑是银河落九天'}
print(dic.items())  # dict_items([(1, '日照香炉生紫烟'), (2, '遥看瀑布挂前川'), (3, '飞流直下三千尺'), (4, '疑是银河落九天')]) # 并非直接的列表
a=list(dic.items())
print(a)  # [(1, '日照香炉生紫烟'), (2, '遥看瀑布挂前川'), (3, '飞流直下三千尺'), (4, '疑是银河落九天')]

6.in/not in（是否存在）

in 操作符用于判断键（key）是否存在于字典（D）中，如果键在字典中返回True，否则返回False。

not in 则相反

dic = {1: '日照香炉生紫烟', 2: '遥看瀑布挂前川', 3: '飞流直下三千尺', 4: '疑是银河落九天'}
print(1 in dic) # True
print(1 not in dic) # False

7.所有键列表（sorted()）

 返回一个有序的包含字典所有key的列表

dic = {1: '日照香炉生紫烟', 2: '遥看瀑布挂前川', 3: '飞流直下三千尺', 4: '疑是银河落九天'}
print(sorted(dic)) # [1, 2, 3, 4]

其他骚操作（dict.fromkeys()，copy() ）

1.可迭代对象做键（dict.fromkeys()）

fromkeys() 方法用于创建一个新的字典，并以可迭代对象中的元素分别作为字典中的键，且所有键对应同一个值，默认为None。

dic.fromkeys(iterable[,value=None])

iterable-- 用于创建新的字典的键的可迭代对象（字符串、列表、元祖、字典）。
value -- 可选参数, 字典所有键对应同一个值的初始值，默认为None

str = "12" # 字符串
dic = {1:'one',2:'two'} # 字典
a=dict.fromkeys(str,'字符串')
print(a) # {'1': '字符串', '2': '字符串'}
a=dict.fromkeys(dic,'字典')
print(a) # {1: '字典', 2: '字典'} #字典是还是用键做新键

2.复制（copy()）

dic.copy() 对字典 dic 进行浅复制，返回一个和dic有相同键值对的新字典。(因为字典的值value可以是可变和不可变数据类型，所以就涉及到了深浅复制)

dic = {1: '日照香炉生紫烟', 2: '遥看瀑布挂前川', 3: '飞流直下三千尺', 4: '疑是银河落九天'}
d=dic.copy()
print(d) # {1: '日照香炉生紫烟', 2: '遥看瀑布挂前川', 3: '飞流直下三千尺', 4: '疑是银河落九天'}

3.字典的嵌套（多级菜单）

menu = {
    '北京': {
        '海淀': {
            '五道口': {
                'soho': {},
                '网易': {},
                'google': {}
            },
            '中关村': {
                '爱奇艺': {},
                '汽车之家': {},
                'youku': {},
            },
            '上地': {
                '百度': {},
            },
        },
        '昌平': {
            '沙河': {
                '老男孩': {},
                '北航': {},
            },
            '天通苑': {},
            '回龙观': {},
        },
        '朝阳': {},
        '东城': {},
    },
    '上海': {
        '闵行': {
            "人民广场": {
                '炸鸡店': {}
            }
        },
        '闸北': {
            '火车站': {
                '携程': {}
            }
        },
        '浦东': {},
    },
    '山东': {},
}

多级菜单

六 集合(set)

集合(set)是一个无序的，把不同的元素(set elements)组成一起形成集合(不重复的数据组合)，它的主要作用如下：

去重:  把一个列表变成集合，就自动去重了(不可重复）

关系测试:  测试两组数据之前的交集、差集、并集等关系

集合分类：可变集合、不可变集合

可变集合(set)：可添加和删除元素，非可哈希的（可变数据类型），不能用作字典的键，也不能做其他集合的元素

不可变集合(frozenset)：不可添加，不可删除元素，可哈希的（不可变数据类型），能用作字典的键，也能做其他集合的元素

list=['一', '弦', '一', '柱', '思', '华', '年']
set=set(list)
print(set)  # {'弦', '华', '思', '柱', '年', '一'}   去重，无序

创建集合

集合的工厂方法set()和frozenset()创建

set1={'一', '弦', '一', '柱', '思', '华', '年'}
print(type(set1))  # <class 'set'>

set2=set('一弦一柱思华年')
print(type(set2))  # <class 'set'>

set3=frozenset('一弦一柱思华年')
print(type(set3)) # <class 'frozenset'>   不可添加，不可删除元素，可哈希的（不可变数据类型）

增（add，update）

.add()添加单个元素（可以重复添加相同的值，但是没用，集合去重的）

set1={'一', '弦', '一', '柱', '思', '华', '年'}
set1.add('诗............')
print(set1)  # {'柱', '诗............', '弦', '华', '思', '一', '年'}  #增加一个元素，可以重复添加相同的值，但是没用，集合去重的

.update()添加一个序列（多个元素）

set1={'一', '弦', '一', '柱', '思', '华', '年'}
set1.update('弓弦')
print(set1)  # {'柱', '诗............', '弦', '华', '思', '弓', '一', '年'} #重复添加相同的值，但是没用，集合去重的

删（remove，discard，pop，del）

.remove()  删除元素，直接要删除指定元素就可以 ，但元素不存在时报错  

.discard()  删除元素，直接要删除指定元素就可以 ，元素不存在时不报错 

.pop()   随机删除一个元素，因为集合是无序的

del 删除集合本身

set1={'一', '弦', '一', '柱', '思', '华', '年'}
set1.remove('一')
print(set1)  # {'思', '年', '弦', '柱', '华'}
set1.discard('思')
print(set1)  # {'年', '弦', '柱', '华'}
del set1


set1.pop()
print(set1)  # {'弦', '柱', '华'}

查

由于集合本身是无序的，所以不能为集合创建索引或切片操作，只能循环遍历或使用in、not in来访问或判断集合元素

set1={'一', '弦', '一', '柱', '思', '华', '年'}
if '一' in set1:
    print('在里面')
if '不存在的' not in set1:
    print('不存在的')
for s in set1:
    print(s)
    
#打印结果
# 在里面
# 不存在的
# 柱
# 弦
# 一
# 思
# 年
# 华

 集合之间的关系

集合等价与不等价(==, !=)；子集、超集；

 

s1={'灭霸','卡魔拉','乌木喉'}  # 灭霸战队
s2={'美国队长','托尼.斯塔克','星爵','卡魔拉'}  # 复仇者联盟阵营
s3={'美国队长','托尼.斯塔克'}  # 妇联
s4={'灭霸','卡魔拉','乌木喉'}  # 灭霸战队
print(s1==s4)  # 集合等价(==)两个集合之间，所有元素完全相等。不等价(!=)两集合之间，存在不相等的元素
print(s3<s2)

s2是s3的子集（'<'表示的是真子集），s3是s2的超集

联合（并集）(|)

联合(union)操作和（|）与集合其实等价的。

 

s1={'灭霸','卡魔拉','乌木喉'}  # 灭霸战队
s2={'美国队长','托尼.斯塔克','星爵','卡魔拉'}  # 复仇者联盟阵营
print(s1|s2)  # {'托尼.斯塔克', '灭霸', '卡魔拉', '美国队长', '乌木喉', '星爵'}
print(s1.union(s2))  # {'托尼.斯塔克', '灭霸', '卡魔拉', '美国队长', '乌木喉', '星爵'}

交集(&)

交集符号的等价方法是intersection()。

s1={'灭霸','卡魔拉','乌木喉'}  # 灭霸战队
s2={'美国队长','托尼.斯塔克','星爵','卡魔拉'}  # 复仇者联盟阵营
s3=s1&s2
print(s3)  # {'卡魔拉'}
s3=s1.intersection(s2)
print(s3)  # {'卡魔拉'}

查集（补集，包括：相等补集，绝对补集）(-)

 等价方法是difference()

 

s1={'灭霸','卡魔拉','乌木喉'}  # 灭霸战队
s2={'美国队长','托尼.斯塔克','星爵','卡魔拉'}  # 复仇者联盟阵营
s3={'美国队长','托尼.斯塔克'}  # 妇联
s4=s2-s1
print(s4)
#{'美国队长', '星爵', '托尼.斯塔克'}
s5=s1-s2
print(s5)
#{'乌木喉', '灭霸'}
s6=s1.difference(s2)
print(s6)
# {'乌木喉', '灭霸'} 等价于 s1-s2
s7=s2.difference(s1)
print(s7)
# {'美国队长', '星爵', '托尼·斯塔克'} 等价于 s2-s1
s8=s2-s3
print(s8)
# {'星爵', '卡魔拉'}
s9=s3-s2
print(s9)
# set() 空集合
s10=s2.intersection(s3)
print(s10)
# {'美国队长', '托尼.斯塔克'}  intersection()函数不适用于绝对补集
s11=s3.difference(s2)
print(s11)
# set() 空集合

对称差集(^)

（ab交接相对于ab并集的补集）取得的元素属于a,b但不同时属于a和b.其等价方法symmetric_difference()

s1={'灭霸','卡魔拉','乌木喉'}  # 灭霸战队
s2={'美国队长','托尼.斯塔克','星爵','卡魔拉'}  # 复仇者联盟阵营
s3={'美国队长','托尼.斯塔克'}  # 妇联
print(s1^s1)  # set()
print(s1^s2)  # {'星爵', '灭霸', '托尼.斯塔克', '美国队长', '乌木喉'}
print(s2^s3)  # {'星爵', '卡魔拉'}
print(s1.symmetric_difference(s2))  # {'星爵', '灭霸', '托尼.斯塔克', '美国队长', '乌木喉'}  等价于s1^s2

---

来来来，常用的数据类型差不多就这些，之后就谈谈它们背后那些不可告人的.......

变量，数据，内存三者的关系（不是三角恋哈）

a='黄河之水天上来，你说奇怪不奇怪'     # id(),是获取数据在内存上的储存地址
print(id('黄河之水天上来，你说奇怪不奇怪'))  # 34507248
print(id(a))  # 34507248

print(id(2*3))  # 1509649584     
print(id(6))    # # 1509649584

可变数据类型与不可变数据类型的爱恨情愁...不对是前世今生

a = ['托尼·斯塔克', '马克系列', '反浩克装甲', '血边战衣']
# 而不可变数据类型则是每一次引用内存地址都是不变的
# 可变数据类型的内存地址引用一次改改变一次
print(id(a))  # 32076360
print(id(['托尼·斯塔克', '马克系列', '反浩克装甲', '血边战衣']))  # 31274056

print(id(a[0]))  # 32006192
print(id('托尼·斯塔克'))  # 32006192

print(id(a[1]))  # 6719984
print(id('马克系列'))  # 6719984

print(id(a[2]))  # 31383040
print(id('反浩克装甲'))  # 31383040

print(id(a[3]))  # 31994216
print(id('血边战衣'))  # 31994216

还是有些迷糊是吧.............啥也不说了，直接上图（图里说）

 

可变数据类型与不可变数据。每次引用可变数据类型时，其内存地址都会改变，当引用不可变数据是，其内存地址都是和第一次引用时相同的。

这个现象的是Python的内存回收机制造成的。

可变数据类型：每当引用可变数据类型数据后，Python会立即回收刚才引用可变数据类型数据分配出去内存，这样就造成下次再引用该可变数据类型数据又要重新分配内存空间给该数据。

不可变数据类型：第一次引用不可变数据类型数据是，Python就会分配一个内存空间给该不可变数据类型数据，第一次引用之后的每一次引用都会找到这个内存空间来取数据，

不在被引用时，其内存空间才会被回收。

 

最后问个问题，Python干嘛要分可变数据类型和不可变数据类型，没事干吃饱了撑的？

欢迎评论留言，番茄，鸡蛋都砸过来吧。