zoukankan html css js c++ java

Python基础-数据类型

# 可变与不可变

    # 可变：在值改变的情况下，id不变，则证明就是在修改原值，即可变类型

    # 不可变：在值修改的情况下，id也跟着改变，则证明没法修改原值，而是重新申请内存空间。 即不可变类型

一、数字类型（init和float）

# 说明：Python中没有数字类型一说，通常我们所说的数字类型是int和float类型

1、int型（整型）

# 用途：
    # 记录年龄、等级、及各种号码等
# 定义方式：
 level=10    # level=int(10)

# 只能将纯数字字符串类型的数据转为init型

>>> res=int('188')
>>> print(res,type(res))
188 <class 'int'>

>>> int('aaaaaaaasdfsadf')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: 'aaaaaaaasdfsadf'

# 常用操作及内置方法

  # 算出运算

  # 比较运算

# 总结：

  # 只能存一个值

  # 不可变类型  >>> x=10
  >>> print(id(x))
  1413600448
  >>> x=11
  >>> print(id(x))
  1413600464

2、float（浮点型）

# 用途
      # 记录工资、身高、体重等

# 定义方式
     weight=50.2      # weight=float(50.2)

# 其他同int型

二、str(字符串类型)

# 用途：记录描述性质的状态，比如名字、爱好等
# 定义方式： 在单引号、双引号、三引号里包含的一串字符
 str="'name=fred' age=15"   # str=str("'name=fred' age=15")
   
# 强调： # 三引号可多行 # 引号嵌套类的，里面单引号的，外面必须是双引号或三引号
 
# 可以将任意数据类型转换为str类型

1、优先掌握的常用操作及内置方法

1）、按索引取值（正向取&反向取）只能取，不能存

userinfo='root:x:0:0:root:/root:/bin/bash'
print(userinfo[0])              # 索引号是从0开始的
r
print(userinfo[-1])
h
 
userinfo[0]='b'
TypeError: 'str' object does not support item assignment # str不支持修改原值

2）切片，从一个大的字符串里切除一个子字符串（顾头不顾尾，步长）

userinfo='root:x:0:0:root:/root:/bin/bash'
print(userinfo[0:4])      # 步长不指定，默认是1

root                      # 顾头不顾尾：[0:4]只能取到前四个字符，第五个字符没取到
print(userinfo[0:4:2])    # 取出索引0-4，步长为2进行取

ro                        # 只能取到第一个字符和第三个字符，步长为2，中间隔了1个

print(userinfo[6:])       # 从第六个字符开始取，到结束

:0:0:root:/root:/bin/bash

# 倒着切片，注意方向要一致

(userinfo[-1:-5:-1])   # 反向取值，一定要指定步长

hsab

(userinfo[-1::-1])     # 从反向第一个字符到最后一个，步长为1

hsab/nib/:toor/:toor:0:0:x:toor

(userinfo[::-1])       # 也可不指定头和尾，意指字符头到尾

hsab/nib/:toor/:toor:0:0:x:toor

3）、切分split：把一个字符串按照某种分隔符切成一个列表

userinfo='root:x:0:0:root:/root:/bin/bash'
print(userinfo.split(':'))      # 按照冒号切分
['root', 'x', '0', '0', 'root', '/root', '/bin/bash']

# 注意： # split还有一个参数：最大切分次数，默认是-1，字符串中有多少分隔符，切几次 # 从左往右切

    userinfo='root:x:0:0:root:/root:/bin/bash'
    print(userinfo.split(':',1))

    ['root', 'x:0:0:root:/root:/bin/bash']

# rsplit # 从右往左切

    userinfo='root:x:0:0:root:/root:/bin/bash'
    print(userinfo.rsplit(':',3))

    ['root:x:0:0', 'root', '/root', '/bin/bash']

4）、join 将列表按照某种分隔符组合一个字符串

userinfo=['root', 'x', '0', '0', 'root', '/root', '/bin/bash']
userinfo_join='|'.join(userinfo)   # 将userinfo列表按|,组合成一个字符串
print(userinfo_join)
root|x|0|0|root|/root|/bin/bash    # 组合的结果

5）、len长度

userinfo='root:x:0:0:root:/root:/bin/bash'
print(len(userinfo))

31                    # 长度为31，所以只能到30 （索引是从0开始的，偷笑）

6）、成员运算in和not in，判断一个字符串是否存在于大的字符串
userinfo='root:x:0:0:root:/root:/bin/bash'
print('bin' in userinfo)
True
print('3' in userinfo)
False
 
# not in  取反

7）、strip移除字符串左右两边的指定字符

userinfo='root:x:0:0:root:/root:/bin/bash....root'
print(userinfo.strip('root'))
:x:0:0:root:/root:/bin/bash....

#规则：
  # 1、从左边开始找指定字符，直到非指定字符为止
  # 2、从右边开始找指定字符，直到非指定字符为止

# 注意：

  # 1、strip() 默认是去除字符串左右两边的空格

  # 2、strip并不是修改原值，而是重新产生一个新值

  userinfo='root:x:0:0:root:/root:/bin/bash....root'
  print(id(userinfo))

89149536


  userinfo=userinfo.strip('root')

(id(userinfo))

88587248# 了解（lstrip rstrip）

  # lstrip   移除字符串左边的指定字符

  # rstrip   移除字符串右边的指定字符

8）、循环

userinfo='ro'
for i in userinfo:
    print(i)
r
o

# 按索引从头到尾循环


for i in range(0,len(userinfo)):
    print(userinfo[i])

2、需要掌握的操作及内置方法

1）lower upper

userinfo='root:x'
print(userinfo.upper())                  #将字符串中的小写字母转换为大写
ROOT:X

# lower  将字符串中的大写字母转换为小写

2）startswitch endswitch

userinfo='root:x'
print(userinfo.startswith('ro'))     # 判断字符串是否以指定字符开头
True
print(userinfo.endswith('x'))        # 判断字符串是否以指定字符结尾
True

3）、format的三种玩法

print('my name is %s my age is %s' %(18,'fred'))         # %s的缺点，占位符和值只能按顺序匹配

print('my name is {name} my age is {age}'.format(age=18,name='fred'))  #format可以不用根据顺序匹配，指定了变量名

print('my name is {} my age is {}'.format(18,'fred'))    # 此种方式，和%s意义一行
print('my name is {0}{0}{0} my age is {1}'.format(18,'fred'))    # 可以按索引号多次匹配

my name is 181818 my age is fred

4）、replace

userinfo='root:x:0:0:root:/root:/bin/bash'
print(userinfo.replace('root','fred'))             # 如果不指定替换次数，默认全部替换
fred:x:0:0:fred:/

fred

:/bin/bash
print(userinfo.replace('root','fred',1))           # 指定替换次数之后，从左往右依次替换N次
fred:x:0:0:root:/root:/bin/bash

5）、isdigit

#　判断字符串是否为纯数字

print('fred123'.isdigit())
False
print('1929'.isdigit())
True

# 只有在字符串中包含的是纯数字的情况下才结果才为True

3、了解的操作及内置方法

1）、find,rfind,index,rindex,count

# find() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，如果包含子字符串返回开始的索引值，否则返回-1。 # 从左向右检索

  # 语法： str.find(str, beg=0, end=len(string))

  # 参数

     str 指定检索的字符串

     beg 开始索引号  默认是0

     end 结束索引号  默认是len(string)

# rfind() 返回字符串最后一次出现的位置(从右向左查询)，如果没有匹配项则返回-1。

# index() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，该方法与 python find()方法一样，只不过如果str不在 string中会报一个异常

# rindex() 返回子字符串 str 在字符串中最后出现的位置，如果没有匹配的字符串会报异常，可以指定可选参数[beg:end]设置查找的区间

# count() 方法用于统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置

# 注意：

   find类都是返回索引号

2）、center,ljust,rjust,zfill

print('我是分隔符'.center(50,'*'))
**********************我是分隔符***********************

print('我是分隔符'.ljust(50,'='))
我是分隔符=============================================

print('我是分隔符'.rjust(50,'0'))
000000000000000000000000000000000000000000000我是分隔符

print('我是分隔符'.zfill(50))
000000000000000000000000000000000000000000000我是分隔符

# zfill() ===  rjust('0')

3)、end

# 指定字符串后面的空格数
# 以九九乘法表为例
for x in range(1,10):
    for y in range(1,x+1):
        print('%sX%s=%s' %(x,y,x*y),end='  ')
    print()
1X1=1
2X1=2 2X2=4 # 字符结尾+2个空格
3X1=3 3X2=6 3X3=9
4X1=4 4X2=8 4X3=12 4X4=16
5X1=5 5X2=10 5X3=15 5X4=20 5X5=25
6X1=6 6X2=12 6X3=18 6X4=24 6X5=30 6X6=36
7X1=7 7X2=14 7X3=21 7X4=28 7X5=35 7X6=42 7X7=49
8X1=8 8X2=16 8X3=24 8X4=32 8X5=40 8X6=48 8X7=56 8X8=64
9X1=9 9X2=18 9X3=27 9X4=36 9X5=45 9X6=54 9X7=63 9X8=72 9X9=81

str总结：

# 1、str为不可变类型
# 2、是有序的（有索引）
# 3、只能存一个值

三、list(列表）

# 用途：用于标识多个值，如一个人有多个爱好
# 定义方式：中括号内用逗号隔开多个任意类型的值

userinfo=['bin', 'x', '1', '1', 'bin', '/bin', '/sbin/nologin']     # userinfo=list(['bin', 'x', '1', '1', 'bin', '/bin', '/sbin/nologin'])

# list的工作原理：list(items)

  # 1、先定义一个空了表

  # 2、然后类似调用一个for循环，从items里取出一个值放入空列表中，循环往复直到值取干净为止

1、优先掌握的常用操作及内置方法

1）、按索引存取值、切片（正向反向存取）：即可存可取

userinfo=['bin', 'x', '1', '1', 'bin', '/bin', '/sbin/nologin']
print(userinfo[0])
bin
print(userinfo[0:3])
['bin', 'x', '1']
print(userinfo[0:5:2])
['bin', '1', 'bin']
print(userinfo[-1])
/sbin/nologin
print(userinfo[-1::-1])
['/sbin/nologin', '/bin', 'bin', '1', '1', 'x', 'bin']
print(userinfo[-1:-5:-2])
['/sbin/nologin', 'bin'
 
print(id(userinfo))
93973280
userinfo[0]='root'                     # 指定索引号修改原值
print(userinfo[0],id(userinfo))
root 93973280

# 注意：此方式只能修改原值，不能新增（list有其独有的新增方法）

userinfo=['bin', 'x', '1', '1', 'bin', '/bin', '/sbin/nologin']
userinfo[7]='bash'

IndexError: list assignment index out of range # 超出了list的最大索引号

2）、len(长度)

userinfo=['bin', 'x', '1', '1', 'bin', '/bin', '/sbin/nologin']
print(len(userinfo))

3）、成员运算(in && not in)

print('bin' in userinfo)
True
print('root' not in userinfo)
True

4)、追加和插入（append && extend && insert ）

# append()  在列表末尾添加新的元素
# insert()  在指定索引号前插入新元素

# extend() 函数用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）

userinfo=['bin', 'x', '1', '1', 'bin', '/bin', '/sbin/nologin']
userinfo.append('this is bin user')            # 此方法没有返回值，但是会修改源列表
print(userinfo)
['bin', 'x', '1', '1', 'bin', '/bin', '/sbin/nologin', 'this is bin user']

userinfo.insert(0,'This is first')               # 两个参数，索引号，新元素  同样没有返回值看，但是会修改源列表
print(userinfo)
['This is first', 'bin', 'x', '1', '1', 'bin', '/bin', '/sbin/nologin']

userinfo=['bin', 'x', '1', '1', 'bin', '/bin', '/sbin/nologin']
userinfo1=['root', 'x', '0', '0', 'root', '/root', '/bin/bash']



userinfo.extend(userinfo1[0:5:2])

# 如果不指定userinfo1的起始索引、结束索引、步长，默认将userinfo1的所有内容追加到userinfo中


print(userinfo)

['bin', 'x', '1', '1', 'bin', '/bin', '/sbin/nologin', 'root', '0', 'root']

5）、删除

# 方式1：通用型删除（并非列表的独有删除方式）
userinfo=['bin', 'x', '1', '1', 'bin', '/bin', '/sbin/nologin']
print(userinfo)           
['bin', 'x', '1', '1', 'bin', '/bin', '/sbin/nologin']    #删除前

del userinfo[-1]                     # 次方法没有返回值       
print(userinfo)
['bin', 'x', '1', '1', 'bin', '/bin']    #删除后

# 方式2 remove
# remove() 函数用于删除列表中某个值的第一个匹配项。
userinfo=['bin', 'x', '1', '1', 'bin', '/bin', '/sbin/nologin']
userinfo.remove('bin')         # 无返回值，userinfo中bin的第一个匹配项
print(userinfo)
['x', '1', '1', 'bin', '/bin', '/sbin/nologin']

# 方式3 pop
# pop()   此方法会删除指定索引号对应的元素，并返回该元素的值
userinfo=['bin', 'x', '1', '1', 'bin', '/bin', '/sbin/nologin']
print(userinfo.pop())                 # 默认删除最后一个索引（-1）
/sbin/nologin                         # 返回该元素的值
print(userinfo)
['bin', 'x', '1', '1', 'bin', '/bin']
print(userinfo.pop(0))                # 可指定索引号
bin
print(userinfo)
['x', '1', '1', 'bin', '/bin']

6）、循环

userinfo=['bin', 'x']     # 根据索引循环（0,len(userinfo)）
for i in userinfo:
    print(i)

2、需要掌握的操作

1）count

# count() 用于统计指定元素在列表中出现的次数
userinfo=['bin', 'x', '1', '1', 'bin', '/bin', '/sbin/nologin']
print(userinfo.count('bin'))
2

2）、index

# index() 函数用于从列表中找出某个值第一个匹配项的索引位置
userinfo=['bin', 'x', '1', '1', 'bin', '/bin', '/sbin/nologin']
print(userinfo.index('bin'))
0

3）sort

# sort() 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数
list1=[5,2,4,8,9,10]
list1.sort()                    # 默认是升序
print(list1)
[2, 4, 5, 8, 9, 10]


list1.sort(reverse=True)        # reverse=True  降序 
[10, 9, 8, 5, 4, 2]
print(list1)

练习：

# 列表模拟队列 ：先进先出

# 入队：
list=[]
list.append('first')
list.append('second')
list.append('third')
print(list)
['first', 'second', 'third']

#出队：
print(list.pop(0))
print(list.pop(0))
print(list.pop(0))
first
second
third

# 列表模拟堆栈  先进后出

# 入栈 
list=[]
list.append('first')
list.append('second')
list.append('third')
print(list)
['first', 'second', 'third']

# 出栈
print(list.pop())
print(list.pop())
print(list.pop())
third
second
first

总结：

# 1、列表类型可以存多个值
# 2、是有序的
# 3、可变类型

四、dict(字典)

# 用途：存多个种类不同的值
# 定义方式：在{}内用逗号隔开多个元素，每个元素都是key:value的形式。key对value有描述性的功能，
   # value可以是任意类型，而key必须是不可变类型且唯一
   # 即字典可以是int float tuple str  通常是字符串类型

d1={'name':'fred','age':18,'commany':'9you'}    # d=dict({'name':'fred','age':18,'commany':'9you'})
d2=dict([['nane','fred'],['age',18]])           # dict转换列表

d3=dict(x=1,y=2,z=3)                            # dict转换元组

d4={}.fromkeys(('name','age','sex'),None)       # 初始化字典

1、优先掌握的常用操作及内置方法

1）、按key存取值

d1={'name':'fred','age':18,'commany':'9you'}
print(d1['name'])       # 按key取值 
fred
d1['name']='Li'         # 按key改值
print(d1)
{'name': 'Li', 'age': 18, 'commany': '9you'}


d1['weight']=50.4

# 新增key

print(d1)
{'name': 'fred', 'age': 18, 'commany': '9you', 'weight': 50.4}

2）、len(长度)

d1={'name':'fred','age':18,'commany':'9you'}
print(len(d1))      # dict len统计的是key的个数

3）成员运算（判断的是字典的key）

d1={'name':'fred','age':18,'commany':'9you'}

print('name' in d1)
True

4）、删除

# pop()删除指定key

# 字典 pop() 方法删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值
d1={'name': 'fred', 'age': 18, 'commany': '9you', 'weight': 50.4}
print(d1.pop('sex',None))              # 如果要pop的key不存在，一定要指定默认返回值，否则会报错
None
print(d1)
{'name': 'fred', 'age': 18, 'commany': '9you', 'weight': 50.4}

print(d1.pop('weight'))                # 如果key存在，则返回key对应的值
50.4
print(d1) 
{'name': 'fred', 'age': 18, 'commany': '9you'}

# 字典 popitem() 方法随机返回并删除字典中的一对键和值(一般删除末尾对)
  #如果字典已经为空，却调用了此方法，就报出KeyError异常。
dict={'name': 'fred', 'age': 18, 'commany': '9you', 'weight': 50.4}

print(dict.popitem())       # 以元组形式返回一对键和值
('weight', 50.4)
print(dict.popitem())
('commany', '9you')

5）、修改key对应的value

# update() 如果key存在，则修改其value。 如果key不存在，则新增   该方法，返回值为None
dict={'name': 'fred', 'age': 18, 'commany': '9you'}
dict.update({'name':'Li'})
print(dict)
{'name': 'Li', 'age': 18, 'commany': '9you'}
dict.update({'sex':'male'})
print(dict)
{'name': 'Li', 'age': 18, 'commany': '9you', 'sex': 'male'}


# setdefault() 如果key值存在，则不修改源，并返回key的值 如果key不存在，则新增此key，并返回其对应的值
dict={'name': 'fred', 'age': 18, 'commany': '9you'}

print(dict.setdefault('name','Li'))
fred
print(dict.setdefault('sex','male'))
male
print(dict)
{'name': 'fred', 'age': 18, 'commany': '9you', 'sex': 'male'}

6）、keys values items

Python2.7 和 Python3.6 差别

msg_dic={
'apple':10,
'tesla':100000,
'mac':3000,
'lenovo':30000,
'chicken':10,
}
print(msg_dic.items())
[('tesla', 100000), ('mac', 3000), ('lenovo', 30000), ('apple', 10), ('chicken', 10)]     
print(msg_dic.keys())
['tesla', 'mac', 'lenovo', 'apple', 'chicken']
print(msg_dic.values())
[100000, 3000, 30000, 10, 10]

# 总结：python2.7会把字典中所有的key

/value/ietms取出来，然后申请的内存空间，调取list功能把这些key/

value一次性存进去。浪费了一倍的内存空间

msg_dic={
'apple':10,
'tesla':100000,
}
print(msg_dic.items())
dict_items([('apple', 10), ('tesla', 100000)])

print(list(msg_dic.items()))     # 将item转换成Python2的存储形式
[('apple', 10), ('tesla', 100000)]

print(msg_dic.keys())
print(type(msg_dic.items()),msg_dic.items())

print(list(msg_dic.keys()))      # 将keys转换成Python2的存储形式
['apple', 'tesla']

print(msg_dic.values())
dict_values([10, 100000])        # 将values转换成Python2存储的形式

print(list(msg_dic.values()))
[10, 100000]

# 总结：
  # Python3在此处做了优化，一次性取出来太浪费内存空间，那就将items/keys/values存成dict_items/dict_keys/dict_values这种类型，此类型仅占很小的内存空间
  # 如果要取对应key/value/items的值 可通过for循环一个个取

7）、循环

msg_dic={
'apple':10,
'tesla':100000,
}

for key in msg_dic.keys():
    print(key)

for values in msg_dic.values():
    print(values)


for key,values in msg_dic.items():
    print(key,values)

8）、get

info={'name':'lichunke','age':18,'company':'9you'}
print(info.get('name'))
lichunke

#取一个不存在的key，也不会报错，返回一个空值（也可自定义输出），代码容错性高
info={'name':'lichunke','age':18,'company':'9you'}
print(info.get('name11111'))
None

#自定义输出
info={'name':'lichunke','age':18,'company':'9you'}
print(info.get('name11111','null'))
null

示例

统计s变量中的每个单词出现的个数#1、比较low的做法s='hello alex alex say hello sb sb'
words=s.split()    #['hello', 'alex', 'alex', 'say', 'hello', 'sb', 'sb']
d={}
for word in words:
    if word not in d:
        d[word]=1            # 当word第一次出现，它的次数为1，即value为1
    else:
        d[word]+=1           # 当word第二次出现，则它的次数+1 
print(d) {'hello': 2, 'alex': 2, 'say': 1, 'sb': 2} 

2、骚操作
s='hello alex alex say hello sb sb'
words=s.split()
d={}
for word in words:    
    d.setdefault(word,words.count(word))      # setdefault 如果key不存在，则新增，如果存在，则不修改原值 
print(d)

　　9）、sorted()对字典的value进行排序

'''
sorted():
    sorted(iterable,key,reverse)，sorted一共有iterable,key,reverse这三个参数
    iterable: 可迭代的对象，例如是dict.items() dict.keys()
    key: 是一个函数，用来选取参与比较的元素
    reverse: 则是用来指定排序是降序还是升序，reverse=true 是降序    reverse=false 是升序   默认是false 
'''

# sorted函数按value值对字典进行排序
# 要对字典的value排序则需要用到key参数，使用lambda表达式的方法:
dic = {'www.abc.com': 2, 'hi.abc.com.cn': 1}
res1 = sorted(dic.items(), key=lambda x: x[1], reverse=True)
# 结果: [('www.abc.com', 2), ('hi.abc.com.cn', 1)]

'''
dic.items()实际上是降dic转换为可迭代对象，迭代对象的元素为('www.abc.com',2)、('hi.abc.com.cn',1),items()方法将字段的元素转化为元组
key参数对应的lambda表达式的意思是选取元组中的第二个元素作为比较参数(key=lambda x: x[0],选取第一个元素作为比较对象  lambda x:y中x表示输出参数  也表示lambda函数的返回值 )

注意: 排序后的返回值是一个list，而原字典中的元素被转换为list中的元组
'''

总结：

# 1、字典是可变类型
# 2、是无序的
# 3、可以存多个值

五、tuple(元组)

# 用途：不可变的列表
# 定义方式：在小括号内用逗号隔开的多个元素
t=('a','b','c') # t=tuple(('a','b','c'))
print(type(t))
<class 'tuple'>

常用操作及内置方法：

1）按索引取值（正向+方向）只能取，不能存改

userinfo=('bin', 'x', '1', '1', 'bin', '/bin', '/sbin/nologin')

print(userinfo[0])
bin

print(userinfo[0:6:2])
('bin', '1', 'bin')

print(userinfo[::-1])
('/sbin/nologin', '/bin', 'bin', '1', '1', 'x', 'bin')

print(userinfo[:-5:-2])
('/sbin/nologin', 'bin')

userinfo[1]='bin'
TypeError: 'tuple' object does not support item assignment         # 元组不支持改值

2）len

userinfo=('bin', 'x', '1', '1', 'bin', '/bin', '/sbin/nologin')
print(len(userinfo))
7

3）成员运算

userinfo=('bin', 'x', '1', '1', 'bin', '/bin', '/sbin/nologin')
print('bin' in userinfo)
True
print('root' not in userinfo)
True

4）循环

userinfo=('bin', 'x')
for i in userinfo:
    print(i)    
bin
x

4）count

userinfo=('bin', 'x', '1', '1', 'bin', '/bin', '/sbin/nologin')
print(userinfo.count('bin'))
2

5）index

userinfo=('bin', 'x', '1', '1', 'bin', '/bin', '/sbin/nologin')
print(userinfo.index('bin'))
0

总结：

# 1、元组是不可变类型
# 2、是有序的
# 3、可以存多个值

六、set(集合)

# 作用：关系运算  去重
# 定义：大括号内逗号分隔开多个元素，
   #注意：
   # 每一个元素必须是不可变类型
   # 集合内元素不能重复（本身有去重的作用）
   # 集合元素是无序的
# s={1,2,3,4,6}    # s=set({1,2,3,4,6})print(type(s))

<class 'set'>


# 定义空集合：
s=set()        # 注意不是 s={}  这就成字典了

1、优先掌握的内置方法和常用操作

1）、关系运算

basket={'apple','pear','orange','banana'}
basket1={'peach','pear','fig','grape'}

# 求两个菜篮子里共有的水果,即求两集合的交集
print(basket & basket1)
print(basket.intersection(basket1))

# 求basket里有的水果，在basket1里没有的，即求两个集合的差集  (有方向的)
print(basket - basket1)
print(basket.difference(basket1))

# 反之就是求basket1里有，而basket里没有的
print(basket1 - basket)
print(basket1.difference(basket))

# 求两个菜篮子里的所有水果,即并集
print(basket | basket1)
print(basket.union(basket1))

# 求没有同时在两个篮子里的水果，即对称差集
print(basket ^ basket1)
print(basket.symmetric_difference(basket1))

2）、子集父集

# 注意:只有两个集合存在包含于包含的关系是，才可以进行大小比较
s1={1,2,3,4}
s2={1,2}

print(s1 >= s2)                  # s1是s2的父集
print(s1.issuperset(s2))         # 等同于s1 >= s2


print(s2 <= s1)                  #反过来s2是s1的子集
print(s2.issubset(s1))           #等同于s2 <= s1

3）、删除元素

s={1,2,3,4}

print(s.pop())        # 随机删除,返回被删除的元素
print(s.discard(2))   # 指定元素删除，返回值为None   如果元素不存在，也不报错
print(s.remove(4))    # 指定元素删除，返回值为None，如果元素不存在，则报错

4）、去重

# 去重：
# 局限性：
  # 不能保证原来的元素顺序
  # 针对可变类型不能去重

userinfo=['bin', 'x', '1', '1', 'bin', '/bin', '/sbin/nologin']
s1=set(userinfo)
print(s1)
{'x', 'bin', '/bin', '1', '/sbin/nologin'}

5）、成员运算和len for循环和其他数据类型一样

练习：

# 需求：
#1、列表内的元素有可变类型
#2、去重之后要保持原来顺序
info=[
    {'name':'egon','age':18},
    {'name':'alex','age':73},
    {'name':'egon','age':18},
    {'name': 'lxx', 'age': 19},
    {'name':'egon','age':18},
    {'name':'lxx','age':19},
]

s=[]

for i in info:
    if i not in s:
        s.append(i)
info=s
print(info)

[{'name': 'egon', 'age': 18}, {'name': 'alex', 'age': 73}, {'name': 'lxx', 'age': 19}]

总结：

# 1、集合是无序的
# 2、是可变的
# 3、可以存多个值 


# 可哈希和不可哈希

# 1、可哈希的数据类型为不可变类型
# 2、不可哈希的数据类型为可变类型

查看全文

相关阅读:
原来这样就可以开发出一个百万量级的Android相机
 微信读书这样排版，看过的人都很难忘！
AI小白快上车！这是发往高薪职位的车！
短视频APP是如何开启你的美好生活的？
自从我这样撸代码以后，公司网页的浏览量提高了107%！
如果想成为一名顶尖的前端，这份书单你一定要收藏！
老板今天问我为什么公司的数据库这么烂，我是这样回答的......
MapReduce Notes
HDFS Architecture Notes
BloomFilter

原文地址：https://www.cnblogs.com/lichunke/p/9267760.html

Python基础-数据类型

一、数字类型（init和float）

1、int型（整型）

2、float（浮点型）

二、str(字符串类型)

1、优先掌握的常用操作及内置方法

1）、按索引取值（正向取&反向取） 只能取，不能存

2）切片，从一个大的字符串里切除一个子字符串（顾头不顾尾，步长）

3）、切分split：把一个字符串按照某种分隔符切成一个列表

4）、join 将列表按照某种分隔符组合一个字符串

5）、len长度

6）、成员运算in和not in，判断一个字符串是否存在于大的字符串

7）、strip移除字符串左右两边的指定字符

8）、循环

2、需要掌握的操作及内置方法

1）lower upper

2）startswitch endswitch

3）、format的三种玩法

4）、replace

5）、isdigit

3、了解的操作及内置方法

1）、find,rfind,index,rindex,count

2）、center,ljust,rjust,zfill

3)、end

str总结：

三、list(列表）

1、优先掌握的常用操作及内置方法

1）、按索引存取值、切片（正向反向存取）：即可存可取

2）、len(长度)

3）、成员运算(in && not in)

4)、追加和插入（append && extend && insert ）

5）、删除

6）、循环

2、需要掌握的操作

1）count

2）、index

3）sort

练习：

总结：

四、dict(字典)

1、优先掌握的常用操作及内置方法

1）、按key存取值

2）、len(长度)

3）成员运算（判断的是字典的key）

4）、删除

5）、修改key对应的value

6）、keys values items

Python2.7 和 Python3.6 差别

7）、循环

8）、get

示例

9）、sorted()对字典的value进行排序

总结：

五、tuple(元组)

常用操作及内置方法：

1）按索引取值（正向+方向）只能取，不能存改

2）len

3）成员运算

4）循环

4）count

5）index

总结：

六、set(集合)

1、优先掌握的内置方法和常用操作

1）、关系运算

2）、子集父集

3）、删除元素

4）、去重

5）、成员运算和len for循环和其他数据类型一样

练习：

总结：

1）、按索引取值（正向取&反向取）只能取，不能存

　　9）、sorted()对字典的value进行排序