python-变量-字符编码-输入输出-字符串-运算-数据类型

pycharm

ctrl+d  复制并粘贴一行
ctrl+y  删除一行
ctrl+?  注释
Ctrl+Shift+Up  或  Ctrl+Shift+Down  上下移动一行
Ctrl + q    快速查看文档

pycharm设置Python版本
File->Settings->Project->Project Interpreter，设置本地安装的Python解释器版本

变量

C语言中变量对应的地址不会改变,在C语言中,变量有两种,普通变量与指针变量

C语言中变量与地址绑定

python语言中变量对应的地址会改变,所以在python中只有一种变量

python变量相当于C中的指针变量

python语言中地址与值绑定

变量 是 为了存储程序运算过程中的一些中间结果，为了方便以后调用
Variables变量 are used to store保存、储存 information信息 to be referenced被以后调用 and manipulated操作或更改 in a computer program程序. They also并且还 provide提供 a way方式 of labeling标记 data数据 with a descriptive描述性 name, so our programs can be understood理解 more clearly更清晰 by the reader阅读者 and ourselves我们自己. It is helpful to think of variables as containers 容器 that hold保持、保存 information(如果我们把变量看作成是一个保存信息的容器是更容易理解的). Their sole主要 purpose目的 is to label标记 and store存储 data in memory内存里. This data数据 can then然后 be used使用它 throughout整个 your program.

• 存储信息 描述信息

变量命名规则

1. 要具有描述性

2. 变量名只能_,数字，字母组成，不可以是空格或特殊字符(#?<.，￥$*!~)

3. 不能以中文为变量名

4. 不能以数字开头

5. 保留字符(语言关键字)是不能被使用

6. 驼峰式、下划线分割

7. 变量名区分大小写

student_number = 30 
studentNumber = 30 
name = "Wu Xing" 
x = 3 
y = 4 
z= x * y 
print("x乘以y=", z) 

常量

不变的量 pi = 3.141592653…在py里面所有的变量都是可变的，所以用全部大写的变量名来代表此变量为常量

变量赋值

name = "Wu Xing" 
name2 = name 
print(name,name2) 
name = "oldboy" 
print(name,name2) 
运行结果 

python c:\hello.pyWu Xing Wu Xingoldboy Wu Xing

变量删除与释放

删除

del age 
释放 

系统定时释放 

没有变量名指向就释放

---

字符编码

支持中文的第一张表 GB2312

1980 gb2312 6700+

1995 gbk1.0 20000

2000 gb18030 27000

unicode 万国码 支持所有国家和地区的编码

2**16 = 65535 = 存一个字符 统一占用2个字节

UTF-8 = unicode 的扩展集，可变长的字符编码集

Assic -->Gb2312 ->gbk1.0–>gb18030

Assic -->unicode -->utf-8 /utf-16

----------> unicode : utf-32 一个字符占4个字节

----------> unicode : utf-16 一个字符占2个字节 65535

----------> unicode : utf-8 一个英文用ASCII码表，一个中文占3个字节

• 编码 encode 语言 —> unicode
• 解码 decode unicode —> 语言

Python2.x == Assic 默认编码

#!-*- coding:utf-8 -*- 
#coding:utf-8 
#!/usr/bin/env python 
#-*- encoding:utf-8 -*- 

python3.x == unicode 默认编码

unicode 是向下兼容gb2312 , gbk

---

注释

单行注释 用#

多行注释用三个单引号或三个双引号 ‘’‘被注释的内容’’’

---

用户输入

input(“xxxxxx:”)

input接收的输入都看作字符串

name = input("your name:") 
age = input("your age:") 
print(name,age) 

运行结果

python c:\hello.pyyour name:Alexyour age:19Alex 19

# 转换成整数 int(被转换的数据) 
# 转换成字符串 str(被转换的数据) 
# 查看数据类型 type(数据) 
death_age = 80 
name = input("your name:") 
age = input("your age:") 
#print(type(age)) 
print("Your name:",name) 
print("You can still live for",death_age-int(age),"years...") 
print("You can still live for " + str(death_age-int(age)) + " years...") 

运行结果

python c:\hello.pyyour name:xxyour age:22Your name: xxYou can still live for 58 years…You can still live for 46 years…

age=int(input('age: ')) 
age=age+2 
print(age) 
print(type(age)) 

age=input('age: ') 
age=int(age)+2 
print(age) 
print(type(age)) 

print输出换行符

print("hello world",end="-") 
print("hello world") 

---

字符串

print("abc","qwe") 
print("abc"+"qwe") 

运行结果

python var.pyabc qweabcqwe

---

算术运算

列表项 
>>> 1+2 
3 
>>> 3-2 
1 
>>> 4*6 
24 
>>> 5/2 
2.5 
>>> 5//2 
2 
>>> 5%2 
1 
>>> 2**10 
1024 
>>> (((2+3)*6+4)*8)*5 
1360 
age_of_princal = 56 
guess_age = int(input(">>:")) 
if guess_age == age_of_princal: 
print("yes") 
else: 
print("no") 
运行结果 

C:\Users\Administrator>python c:\hello.py>>:45noC:\Users\Administrator>python c:\hello.py>>:56yes

---

比较运算

True 真 正确的

False  假 错误的 

 >>> a=3 
>>> b=5 
>>> a>b 
False 
>>> a<b 
True 
>>> a == b 
False 
>>> a != b 
True 
>>> a >= b 
False 
>>> a <= b 
True 
a = 300 
b = 100 
c = 1000 
if b <= a <= c: 
print("yes") 
else: 
print("no") 
输出三个数中的最大值 

前两个数作比较，比较大的数在与第三个数比较

num1 = int(input("num1:")) 
num2 = int(input("num2:")) 
num3 = int(input("num3:"))  if num1 > num2: 
max_num = num1 
if num3 > max_num: 
max_num = num3 
elif num2 > num1: 
max_num = num2 
if num3 > max_num: 
max_num = num3 
print("max_num",max_num) 

---

赋值运算

>>> num =1 
>>> num += 2 
>>> num 
3 
>>> num -= 1 
>>> num 
2 
>>> num *= 2 
>>> num 
4 
>>> num /= 2 
>>> num 
2.0 
>>> num = 4 
>>> num //= 2 
>>> num 
2 
>>> num = 5 
>>> num %= 2 
>>> num 
1 
>>> num = 5 
>>> num **= 2 
>>> num 
25 

---

逻辑运算

短路原则

and 与

条件1 and 条件2

• 有假为假

• 全真为真

>>> 5>3 and 6>2 
True 
>>> 5>3 and 6<2 
False 

or 或

条件1 and 条件2

• 有真为真

• 全假为假

>>> 5>3 or 6<2 
True 
>>> 5<3 or 6<2 
False 

not 非

真为假
假为真

>>> not 5>3 
False 
>>> not 5<3 
True 

---

身份运算 is

num = 1 
if type(num) is int: 
print('right') 

成员运算 in 、not in

表达式

操作数与运算符组成

---

格式化输出

占位符 %s s = string

%d d = digit 整数

%f f = float 浮点数，约等于小数

name = input("name: ") 
age = input('age: ') 
print('hello,%s!年龄：%s'%(name,age)) 

name = input("Name:") 
age = int(input("Age:")) 
job = input("Job:") 
salary = input("Salary:")  if salary.isdigit(): #是否为数字 
salary = int(salary) 
# else: 
#     exit("must input digit") #退出程序  msg = ''' 
------------info of %s -------- 
Name: %s 
Age : %s 
Job : %s 
Salary: %f 
You will be retired in %s years 
------------ end ------------ 
''' %(name,name,age,job,salary,65-age)  print(msg) 

---

数据类型

https://www.cnblogs.com/yuanchenqi/articles/5782764.html

• 不可变类型： 整型，浮点，字符串，元组
• 可变类型： 列表，字典

https://www.cnblogs.com/Eva-J/articles/7074818.html

1、数字

整数 int(integer)

整形

长整形

py3 已经不区分整形与长整形，统一都叫整形

type(2**32) 
<class 'int'>  type(2**64) 
<class 'int'> 

浮点数

complex（复数）

x+yj

(-5+4j)+(3+3j) 
(-2+7j) 

2、布尔

只有2种状态，分别是

• 真 True
• 假 False

>>> a=90 
>>> score=87 
>>> score > a 
False 
>>> score < a 
True 

3、字符串 str

“Hello World”

• 计算机中， 一切皆为对象

• 世界万物，皆为对象，一切对象皆可分类

字符串拼接

加法

a='123' 
b='abc' 
c=a+b 
print(c) 

乘法

a="Let's go" 
print(a*2) 

字符串 join方法 （字符串拼接）

a='123' 
b='abc' 
d='44' 
c='*****'.join([a,b,d]) 
print(c) 
运行结果 

123*****abc*****44 

字符串切片（跟列表相同）

a="Let's go" 
print(a[1::2]) 

in (返回布尔值)

a="Let's go" 
print('et' in a) 
print('en' in a) 

repr # 便于计算机阅读

a = repr('he is happy \n Yes') 
print(a) 

字符串内置方法

st='hello kitty' 
print(st.count('l'))  # 统计元素个数 
print(st.capitalize())  #字符串首字母大写 
print(st.center(50,'-')) #居中显示字符串，两边用-补齐，总长度为50  print(st.endswith('y'))  #以y结尾，返回真 
print(st.startswith('he')) #以he开头，返回真 
print(st.expandtabs(tabsize=10)) 
print(st.find('t'))   #查找到第一个元素，并将索引值返回  st='hello kitty {name} is {age}' 
print(st.format(name='alex',age=37))  #格式化输出另一种方式 
print(st.format_map({
    
    'name':'alex','age':22})) 
#print(st.index('q'))  # is系列 
print('abc456'.isalnum()) 
print('0b010'.isdecimal())  # 是否为十进制数 
print('123342345'.isdigit()) #是否为整数 
print('124234'.isnumeric())  # 是否为整数 
print('34abc'.isidentifier())  # 是否非法变量 
print('abc'.islower())  #是否全为小写字母 
print('ABC'.isupper())  #是否全为大写字母 
print('  '.isspace())  #是否全为空格 
print('My Title'.istitle()) #是否每个单词开头为大写  # 大小写转换 
print('My Title'.lower())  #所有大写字母转换为小写字母 
print('My Title'.upper())  #所有小写字母转换为大写字母 
print('My Title'.swapcase())  #所有大写字母转换为小写字母，所有小写字母转换为大写字母 
print('My Title'.ljust(50,'*')) #字符串在左侧，右边用*补齐 
print('My Title'.rjust(50,'*')) #字符串在右侧，左边用*补齐  # strip系列 
# 去掉前面和后面的内容（默认为空格、tab、回车） 
print('   \tMy Title\n'.strip()) #去掉字符串前后的空格、tab、回车 
print('   \tMy Title\n'.lstrip()) #去掉字符串左边的空格、tab、回车 
print('   \tMy Title\n'.rstrip()) #去掉字符串右边的空格、tab、回车 
print('ok')  print('My title title'.replace('title','lesson',1))  #替换一处字符串 
print('My title title'.rfind('t'))  #从右边找t，返回索引  # split系列 
print('My title title'.split(' '))  #空格为分隔符，切割字符串，并转换为列表 
print('My title title'.split('i'))  #i为分隔符，切割字符串，并转换为列表 
print('My title title'.split('i',1))  #i为分隔符，切割字符串,切割一次，并转换为列表 
print('My title title'.rsplit('i',1))  # 从右边切割，i为分隔符，切割一次  print('My title title'.title()) #每个单词开头大写 

---

4、列表 list

• 顾头不顾尾
• [初值：终值：步长] （步长可正可负）
• 列表元素可以是任意数据类型

a=['wuchao','jinxin','xiaohu','sanpang','ligang'] 


 列表创建方式 

a=[] 
a=list() 

list 查（切片）

print(a[1:3]) 
print(a[1:-1]) #取到倒数第二个值 
print(a[1:]) #取到最后一个值 
print(a[1::2]) #步长为2  print(a[3::-2]) 
print(a[3::-1]) 

统计元素出现次数（count）

a=['to','be','or','not','to','be'] 
print(a.count('to')) 

取出元素在列表中的位置(下标)

a=['wuchao','jinxin','xiaohu','sanpang','ligang'] 
print(a.index('jinxin')) 
# 取出第二个ligang的位置 
a=['wuchao','jinxin','xiaohu','ligang','sanpang','ligang']  first_lg_index = a.index('ligang') 
print('first_lg_index',first_lg_index)  little_list = a[first_lg_index+1:]  second_lg_index = little_list.index("ligang") 
print('second_lg_index',second_lg_index)  second_lg_index_in_big_list = first_lg_index + second_lg_index +1  print('second_lg_index_in_big_list',second_lg_index_in_big_list) 
print("second lg:",a[second_lg_index_in_big_list]) 

元素是否在列表中

"haidilao ge" in a 

list 增（写）

append（追加）

a.append("xuepeng") 
print(a) 

insert（插入）

a.insert(1,'xuepeng')  # 1 是 下标 
print(a) 

把一个列表添加到另一个列表中 extend

a=[1,2,3] 
b=[4,5,6] 
a.extend(b) 
print(a) 
print(b) 

list 改（写）

a[1]='haidilao' 
print(a)  a[1:3]=['a','b'] 
print(a) 

list 删（写）

remove

a.remove('wuchao') 
print(a) 

pop 删除list元素并返回删除的元素（*）

根据索引删除，默认删除最后一个元素 

 b=a.pop(1) # pop删除的值可以重新接收 
print(a) 
print(b) 

del

del a[0] 
print(a) 
del a  # 直接删除对象，对象将无定义 
print(a) 

清空列表

a.clear() 

list 排序（写）

倒序 reverse

a=['wuchao','jinxin','xiaohu','ligang','sanpang','ligang'] 
a.reverse() 
print(a) 

排序(按ASCII表顺序排序)

a.sort() 
print(a) 

身份判断

>>> type(a) is list 
True 

嵌套

a=[[1,2,3],'wuxing',4,(2,3,4)] 
print(a[0][1]) 
a[0][2]=4 
print(a) 

多变量赋值

a,b = [2,3] 
print(a) 
print(b) 

enumerate

a=['a','b','c','d'] 
for i,k in enumerate(a): 
print(i,k) 
运行结果 

0 a 
1 b 
2 c 
3 d 

深浅拷贝

s=[1,'alex','alvin'] 
s2=s.copy() 
print(s2) 
s2[0]=3 
print(s) 
print(s2) 

s=[[1,2],'alex','alvin'] 
s3=s.copy() 
print(s3) 
s3[0][1]=3 
print(s3) 
print(s) 

import copy 
hasband = ['xiaohu',123,[15000,9000]] 
#浅拷贝 
wife = hasband.copy() 
wife[0] = 'xiaopang' 
wife[1] = '456' 
hasband[2][1] -= 4000 
#深拷贝 
xiaosan = copy.deepcopy(hasband) 
xiaosan[0] = 'jinxin' 
xiaosan[1] = '666' 
xiaosan[2][1] -= 3000  print(hasband) 
print(wife) 
print(xiaosan)  

5、元组 tuple （只读列表）

• 只有一个元素时 (12,)

a=(1,2,3,4)

实例 购物车

product_list=[ 
('Mac',9000), 
('kindle',800), 
('tesla',900000), 
('python book',105), 
('bike',2000), 
]  saving=input('please input your money:') 
shopping_car=[] 
if saving.isdigit(): 
saving=int(saving) 
while True: 
#打印商品内容 
for i,v in enumerate(product_list,1): 
print(i,'>>>>>>>>',v) 
#引导用户选择商品 
choice=input('选择购买商品编号[退出：q]：')  #验证输入是否合法 
if choice.isdigit(): 
choice=int(choice) 
if choice > 0 and choice <= len(product_list): 
#将用户选择商品取出 
p_item=product_list[choice-1]  #如果钱够，用本金saving-商品价格，并将商品加入购物车 
if p_item[1] < saving: 
saving -= p_item[1] 
shopping_car.append(p_item) 
else: 
print('余额不足，还剩%s'%saving) 
print(p_item) 
else: 
print('不存在') 
elif choice == 'q': 
print('------您已经购买如下商品-----') 
#循环变量购物车中的商品，购物车存放的是已买商品 
for i in shopping_car: 
print(i) 
print('您还剩%s元钱'%saving) 
break 
else: 
print('invalid input') 

6、字典 dic

python对key进行哈希函数运算，根据计算的结果决定value的存储地址

• 字典是无序的
• key-value形式存储
• key 是唯一的（不可变）

dic={
    
    'name':'alex','age':35,'hobby':'girl'} 
print(dic['hobby']) 
字典创建方式 

dic1={
    
    } 
dic2=dict((('name','alex'),('age',18))) 

增

dic1={
    
    'name':'alex'} 
dic1['age']=18 

setdefault

• 如果key存在，则返回其值
• 如果key不存在，则创建key，并返回其值

dic1={
    
    'name':'alex'} 
dic1['age']=18 
print(dic1)  dic1.setdefault('hobby','girl') 
ret2=dic1.setdefault('age',34) 

查

dic1={
    
    'name':'alex','age':18,'hobby':'girl'}  # 查询键对应的值 
print(dic1['name'])  # 查询'name'键对应的值 
print(dic1.keys())   # 查询所有键
print(dic1.values()) # 查询所有值
print(dic1.items())  # 查询所有键值对(项)
字典转换为列表 

print(list(dic1.keys())) 
print(list(dic1.values())) 
print(list(dic1.items())) 
运行结果 

 ['name', 'age', 'hobby'] 
['alex', 18, 'girl'] 
[('name', 'alex'), ('age', 18), ('hobby', 'girl')] 

删

dic5={
    
    'name':'alex','age':18,'class':1} 

del dic5['name'] 
print(dic5) 

clear 清空字典

dic5.clear() 
print(dic5) 

pop 删除并返回值

ret=dic5.pop('age') 
print(ret) 
print(dic5) 

popitem 随机删 并返回值

a= dic5.popitem() 
print(a,dic5) 

删除整个字典

del dic5 
print(dic5) 

改

dic1['age']=55 

update

dic4={
    
    'name':'alex','age':18,'hobby':'girl'} 
dic5={
    
    '1':'111','name':'222'} 
dic4.update(dic5) 
print(dic4) 
print(dic5) 
运行结果 

{
    
    'name': '222', 'age': 18, 'hobby': 'girl', '1': '111'} 
{
    
    '1': '111', 'name': '222'} 

其它操作

fromkeys

dic6=dict.fromkeys(['host1','host2','host3'],'test') 
print(dic6) 
运行结果 

{
    
    'host1': 'test', 'host2': 'test', 'host3': 'test'} 

字典嵌套

av_catalog = {
    
     
"欧美":{
    
     
"www.youporn.com": ["很多免费的,世界最大的","质量一般"], 
"www.pornhub.com": ["很多免费的,也很大","质量比yourporn高点"], 
"letmedothistoyou.com": ["多是自拍,高质量图片很多","资源不多,更新慢"], 
"x-art.com":["质量很高,真的很高","全部收费,屌比请绕过"] 
}, 
"日韩":{
    
     
"tokyo-hot.com":["质量怎样不清楚,个人已经不喜欢日韩范了","听说是收费的"] 
}, 
"大陆":{
    
     
"1024":["全部免费,真好,好人一生平安","服务器在国外,慢"] 
} 
}  av_catalog["大陆"]["1024"][1] += ",可以用爬虫爬下来" 
print(av_catalog["大陆"]["1024"]) 

排序 sorted函数

dic={
    
    5:'555',2:'666',4:'444'} 
print(sorted(dic)) 

字典遍历

#默认遍历key
for i in dic5:
    print(i)
    # 取key value
    print(i,dic5[i])
    
# 遍历key
for i in dic5.keys():
    print(i)

# 遍历value
for i in dic5.values():
    print(i)

# 遍历key-value
for k,v in dic5.items():
    print(k,v)

字典存放人员信息

dic={
    
    
    'zhangsan':{
    
    
        'age':23,
        'sex':'male'
    },
    'lisi':{
    
    
        'age':34,
        'sex':'male'
    },
    'wangwu':{
    
    
        'age':25,
        'sex':'women'
    }
}

print(dic['zhangsan'])
print(dic['wangwu']['sex'])

三级菜单(简单版)

menu = {
    
    
    '北京':{
    
    
        '朝阳':{
    
    
            '国贸':{
    
    
                'CICC':{
    
    },
                'HP':{
    
    },
                '渣打银行':{
    
    },
                'CCTV':{
    
    },
            },
            '望京':{
    
    
                '陌陌':{
    
    },
                '奔驰':{
    
    },
                '360':{
    
    },
            },
            '三里屯':{
    
    
                '优衣库':{
    
    },
                'apple':{
    
    },
            },
        },
        '昌平':{
    
    
            '沙河':{
    
    
                '老男孩':{
    
    },
                '阿泰包子':{
    
    },
            },
            '天通苑':{
    
    
                '链家':{
    
    },
                '我爱我家':{
    
    },
            },
            '回龙观':{
    
    },
        },
        '海淀':{
    
    
            "五道口":{
    
    
                "谷歌":{
    
    },
                "网易":{
    
    },
                "sohu":{
    
    },
                "sogo":{
    
    },
                "快手":{
    
    },
            },
            "中关村":{
    
    
                'youku':{
    
    },
                'iqiyi':{
    
    },
                '汽车之家':{
    
    },
                '新东方':{
    
    },
                'QQ':{
    
    },
            },
        },
    },
    '上海':{
    
    
        "浦东":{
    
    
            "陆家嘴":{
    
    
                "CICC":{
    
    },
                "高盛":{
    
    },
                "摩根":{
    
    },
            },
            "外滩":{
    
    },
        },
        "闵行":{
    
    },
        "静安":{
    
    },
    },
    '山东':{
    
    
        "济南":{
    
    
        },
        "德州":{
    
    
            "乐陵":{
    
    
                "丁务镇":{
    
    },
                "城区":{
    
    },
            },
            "平原县":{
    
    },
        },
        "青岛":{
    
    },
    },
}


back_flag = True
exit_flag = True
while back_flag and exit_flag:
    for key in menu:
        print(key)   #北京
    choice = input(">>:").strip()
    if choice == 'b':
        back_flag = False
    if choice == 'q':
        exit_flag = False
    if choice in menu:
        while back_flag and exit_flag:
            for key2 in menu[choice]:
                print(key2)   #昌平
            choice2 = input("2>>:").strip()
            if choice2 == 'b':
                back_flag = False
            if choice2 == 'q':
                exit_flag = False
            if choice2 in menu[choice]:
                while back_flag and exit_flag:
                    for key3 in menu[choice][choice2]:
                        print(key3)   #沙河
                    choice3 = input("3>>:").strip()
                    if choice3 == 'b':
                        back_flag = False
                    if choice3 == 'q':
                        exit_flag = False
                    if choice3 in menu[choice][choice2]:
                        while back_flag and exit_flag:
                            for key4 in menu[choice][choice2][choice3]:
                                print(key4)  #老男孩
                            choice4 = input("4>>:").strip()
                            print("last level")
                            if choice4 == 'b':
                                back_flag = False
                            if choice4 == 'q':
                                exit_flag = False
                        else:
                            back_flag = True
                else:
                    back_flag = True
        else:
            back_flag = True

三级菜单（高级版）

current_layer = menu # 保存当前状态
parent_layers = []  #状态列表

while True:
    for key in current_layer:
        print(key)
    choice = input(">>>:").strip()
    if len(choice) == 0:continue
    if choice in current_layer:
        parent_layers.append(current_layer)  #修改状态时，把当前状态追加到列表中
        current_layer = current_layer[choice] #修改当前状态
    elif choice == "b":
        if parent_layers: #列表不空
            current_layer = parent_layers.pop() #返回时，弹出列表最后一项，赋给当前状态
    elif choice == 'q':
        break
    else:
        print("无此项")

其它数据类型转换为字典

eval(a) 

7、集合（set）

集合是一个无序的， 不重复 的数据组合，它的主要作用如下：

去重，把一个列表变成集合，就自动去重了

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

 集合(set)：把不同的元素组成一起形成集合，是python基本的数据类型。 

 集合元素(set elements):组成集合的成员(不可重复) 

 s={
    
    1,2,3,'a','bc'} 
print(type(s))  li=[1,2,'a','b'] 
s =set(li) 
print(s)    # {1, 2, 'a', 'b'} 
 
li2=[1,2,1,'a','a'] 
s=set(li2) 
print(s)  #{1, 2, 'a'} 

• 集合对象是一组无序排列的可哈希的值：集合成员可以做字典的键

li=[[1,2],'a','b'] 
s =set(li) #TypeError: unhashable type: 'list' 
print(s) 

集合分类

可变集合、不可变集合

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

• 不可变集合(frozenset)：与上面恰恰相反

li=[1,'a','b'] 
s =set(li) 
dic={
    
    s:'123'} #TypeError: unhashable type: 'set' 

集合的相关操作

1、创建集合

由于集合没有自己的语法格式，只能通过集合的工厂方法set()和frozenset()创建 

 s1 = set('alvin') 
s2= frozenset('yuan')  print(s1,type(s1))  #{'l', 'v', 'i', 'a', 'n'} <class 'set'> 
print(s2,type(s2))  #frozenset({'n', 'y', 'a', 'u'}) <class 'frozenset'> 

2、访问集合

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

 s1 = set('alvin') 
print('a' in s1) 
print('b' in s1) 
#s1[1]  #TypeError: 'set' object does not support indexing 
 
for i in s1: 
print(i) 
# 
# True 
# False 
# v 
# n 
# l 
# i 
# a 

3、修改集合

可使用以下内建方法来更新：

s.add() 
s.update() 
s.remove() 

• 注意只有可变集合才能更新

# s1 = frozenset('alvin') 
# s1.add(0)  #AttributeError: 'frozenset' object has no attribute 'add' 
 
s2=set('alvin') 
s2.add('mm') 
print(s2)  #{'mm', 'l', 'n', 'a', 'i', 'v'} 
 
s2.update('HO')#添加多个元素 
print(s2)  #{'mm', 'l', 'n', 'a', 'i', 'H', 'O', 'v'} 
 
s2.remove('l') 
print(s2)  #{'mm', 'n', 'a', 'i', 'H', 'O', 'v'}  s2.pop()    #从左到右删除  

del：删除集合本身

集合类型操作符

in ,not in

集合等价与不等价(==, !=)

子集、超集 

 s=set('alvinyuan') 
s1=set('alvin') 
print('v' in s) 
print(s1<s) 

并集(|)

联合(union)操作与集合的or操作其实等价的，联合符号有个等价的方法，union()。 

 s1=set('alvin') 
s2=set('yuan') 
s3=s1|s2 
print(s3)  #{'a', 'l', 'i', 'n', 'y', 'v', 'u'} 
print(s1.union(s2)) #{'a', 'l', 'i', 'n', 'y', 'v', 'u'} 

交集(&)

与集合and等价，交集符号的等价方法是intersection() 

 s1=set('alvin') 
s2=set('yuan') 
s3=s1&s2 
print(s3)  #{'n', 'a'} 
 
print(s1.intersection(s2)) #{'n', 'a'} 

差集(-)

等价方法是difference() 

 s1=set('alvin') 
s2=set('yuan') 
s3=s1-s2 
print(s3)  #{'v', 'i', 'l'} 
 
print(s1.difference(s2)) #{'v', 'i', 'l'} 

对称差集(^)

对称差分是集合的XOR(‘异或’)，取得的元素属于s1,s2但不同时属于s1和s2.其等价方法symmetric_difference() 

 s1=set('alvin') 
s2=set('yuan') 
s3=s1^s2 
print(s3)  #{'l', 'v', 'y', 'u', 'i'} 
 
print(s1.symmetric_difference(s2)) #{'l', 'v', 'y', 'u', 'i'} 


 应用 

 '''最简单的去重方式''' 

lis = [1,2,3,4,1,2,3,4] 
print list(set(lis))    #[1, 2, 3, 4]