（3）基本数据类型（字符串、列表、字典、元组、集合）以及切片和常用操作

基本数据类型--数字

bool（布尔型）

只有两个值True和False，之所以将bool归类为数字，是因为我们习惯用1表示True，0表示False

int类型

Python中的整数属于int类型，默认用十进制表示，此外也支持二进制，八进制，十六进制表示方式

float（浮点数）

Python中的float（浮点数）就是数学中的小数（float是有限小数或无限循环小数），在运算中整数和浮点数运算的结果也是一个浮点数 一个浮点数的小数点位置是可变的，Python默认的小数精度是17位，也就是小数点后面16位，越往后越不准。其他语言也同样的问题。小数不精准是因为在转换成二进制的过程中会出现无线循环，在约省的时候就会出现偏差

 

基本数据类型--字符串

字符串是一个有序的字符的集合，用于存储和表示基本的文本信息，''或'' ''或''' '''中间包含的内容称之为字符串，字符串只能存一个值，而且是不可变

PS：字符串比较特殊，虽然是不可变的，但是可以被迭代

 

字符串的操作

切片格式：s[start_index:end_index:strp]： 表示对变量s进行切片索引，start_index表示起始位置，end_index表示结束位置，strp则表示步长

PS:正向索引时候因为是从0开始，所以0-7显示的对应值其实就是0-6的值。参考索引位置

PS:反向索引是从1开始计数

 

按索引取值(正向取+反向取) ：只能取

s1="hello world"

s1[0]  #索引0号位置的值

s1[-1]  #反向索引第一个值

s1[-3]  #反向索引第三个值

print(s1[-1:-4:-1])  #反向索引1-4的值

 

切片(顾头不顾尾从大字符串中切出一个子字符串)

例：顺序切片

s=abcdefghijklmn s[0:7:2]   #则表示从0-7，步长2，就是从每两个位置取一个值,输出则是aceg

例：反转切片

s=abcdefghijklmn s[::-1]   # 倒过来索引，其实就是把值反过来输出nmlkjihgfedcba

例：顺序切片

s=abcdefghijklmn s[::2]    #则表示从开始到结束（len的长度范围呢），步长2，就是每两个位置取一个值,输出则是acegikm

例：反转切片

s=abcdefghijklmn s[::-1][0:7]   # 先将s的值倒过来索引，然后输出0-6位置的值

例：反转切片

s=abcdefghijklmn s[:2][::-1]    #先取前两位的值，再倒过来输出

PS：字符串的单引号和双引号都无法取消特殊字符的含义， 如果想让引号内所有字符均取消特殊意义，在引号前加r。 如name = r‘l\thf’

PS:unicode字符串与r连用必须在r前面，如name=ur'l\thf'

 

len(s1)  #查看字符串的长度

 

成员运算in和not in:判断一个子字符串是否存在于一个大字符串中

msg='my name is alex,alex is dsb'   #判断一个字符串是不是在另一个字符串中

print('alex' in msg)

print('egon' not in msg)

 

移除

移除空白strip: 移除字符串左右两边的字符 （lstrip和rstrip分别是移除左边和右边）

name=input('username>>>: ').strip()   #这是一种操作，直接在input函数后面跟strip方法，移除用户输入的字符前后的空格,括号内可以指定一个

name=name.strip()   #也可以这样重新赋值一次，如果在strip(' * ')括号内指定字符，则可以去除字符串前后被指定的字符，可以指定单个，也可以指定多个 print(msg.strip('*&^$/-?#='))

if name == 'egon':

print('认证成功') 

 

切分

切分split: 把一個有規律的字符串按照某個字符進行切分,切成列表  # rsplit表示从右边开始

info='root:x:0:0::/root:/bin/bash'

res=info.split(':',maxsplit=-1)   #如果maxsplit这个参数没有指定或者是-1，这时分割次数不会有限制

print(res)

 

info=''   #将下列列表，换成：

userinfo=['root', 'x', '0', '0', '', '/root', '/bin/bash']

for item in userinfo:  #即

    item+=':'

    info+=item

    info=info.strip(':')

    print(info,type(info))

#用join方法将 ‘，’换成‘：‘

userinfo=['root', 'x', '0', '0', '', '/root', '/bin/bash']

res=':'.join(userinfo)

 

循环

msg='hello'

for item in msg:

    print(item)

 

讲字符串转换成小写或大写

lower() #将字符串全部变成小写，upper()  #将字符串全部变成大写

x='ABBBBddd1231'

print(x.lower())

print('ABBBBddd2123'.upper())

 

查找指定字符开头或自定字符结尾的字符串

startswith() ,endswith()  #satrtswith()括号内添加指定的值，就以这个指定的值查找相关开头的字符串，endswitch()括号内添加指定的值，就以这个指定的值查找相关开头的字符串

print('alex is sb'.startswith('alex'))

print('alex is sb'.startswith('al'))

print('alex is sb'.endswith('sb'))

 

格式化字符串传入参数

几种方式

msg='my name is %s my age is %s' %('egon',18)  #这个利用占位符%来传入

msg='my name is {name} my age is {age}'.format(age=18,name='egon') #这个利用format()函数来传入

msg='my name is {} my age is {}'.format(18,'egon')   #利用format传入，如果没有指定传入参数，那就按照位置传入，有点类似占位符%的原理

msg='my name is {0} my age is {0}{1}{1}'.format(18,'egon')  #利用format传入，在想要传入值得位置写入数字，那就按照数字的排序对应format括号里值得位置排序传入

 

替换字符串内的某个值

msg='alex is alex hahahah alex'

res=msg.replace('alex','SB',1)

 

 

 

什么是列表

在[]内用逗号分隔，可以存放n个任意类型的值，而且可以被迭代

列表的定义：[]内已逗号分隔，按照索引，存放各种数据类型，每个位置代表一个元素

students=['egon','alex','wupeiqi',]

用于标识：存储多个值的情况，比如一个人有多个爱好

 

列表的创建

list_test = ['张三'，'李四'，'alex']

#或

list_test = list('alex')

#或

list_test = list(['张三','李四','alex'])

 

列表的特点

特性：

1、可存放多个值

2、按照从左到右的顺序定义列表元素，下标从0开始顺序访问，有序的访问

3、可修改指定索引位置对应的值，可变，可迭代

 

列表嵌套和取值

存放多个学生的信息：姓名，年龄，爱好
students_info=[['egon',18,['play',]],['alex',18,['play','sleep']]]
students_info[0][2][0] #取出第一个学生的第一个爱好

 

列表常用操作

 索引

names=['egon','alex','kevin']

print（name[0]）  #索引0号位置的值

names[-1]=1000   #修改最后一个值

names[3]='aaaa'  #修改3号位置的值

 

切片（顾头不顾尾，也包含步长）[num:num:num](start，end，step)

i = ['egon','alex','seven','yuan']

i[0:2]  # 指输出从0开始到2的所有内容

i[:2]   #由于没有指定开始位置，python会默认从0开始，所以指输出2前面所有的内容

i[2:]   #指输出2后面所有的内容

i[:]   #指输出所有的内容

i[::2]   #由于没有指定开始和结束位置，所以python会默认从0开始到最后一个值，所以指每隔2个值提取一次

i[::-1]  #指反向切片

 

列表的添加和删除

i.append('eva')   #将一个值添加到列表的末尾

i.remove('eva')   #从列表中删除一个值

i.pop()   #在括号内添加指定数字，就可以删除列表指定位置的元素.括号内可以指定

del i[0]  #用del方法直接删除指定位置的字符串

 

i.append('xxxx') #将括号内指定的字符添加至列表的末尾

i.insert(0,'chenwei') #在列表的任意位置添加内容，insert(位置，内容)

 

 

查看列表和判定列表中是否包含某个值

len(i)   #查看列表的长度

'egon' in i   #查看一个值是否包含在列表中，包含则返回True，反则False

i.count('egon') #查看指定元素在列表中出现的次数

i.index('egon'))  #计算对象在列表中索引的位置

i.sort(reverse=True)  #永久性的将列表按照顺序排列，reverse=true则表示相反，括号内不指定则默认reverse=False

i.reverse( )   #把列表元素相反打印,reversed()函数返回的是一个迭代器，而不是一个List，所以需要list函数转换一下.(参数可以是列表，元组，字符串，不改变原对象)

 

分割

>>>s = 'hello world'

>>>s.split(' ') 以空格为分隔符，分割字符串

>>>s.split(',') 以逗号为分隔符，分割字符串

PS：分隔符不限定，但是必须根据需求

 

连接

>>>i = ['hi','eva']

>>>'!'.join(i)

'hi!eva'

例 str = "-"

    seq = ("a", "b", "c")

    print str.join( seq )

    a-b-c

PS:以逗号为分隔符，将字符串以' - '符号连接

 

什么是元组

与列表相似，列表用[]，元组是（）表示，元组相当于不可变的列表

如果存的多个值只有取的需求没有改的需求,用tuple最合适，占用内存最小

特性

1、可存放多个值，而且可存放数字、字符串，还可以存放更加复杂的数据类型

2、元组本身不可修改和改变，如果元组中包含其他可变元素，这些元素可改变

3、按照从左到右的顺序定义元组元素，下标从0开始顺序访问，有序的访问

 

创建元组

ages = (1,2,3,4,5,6)

#或

ages = tuple(1,2,3,4,5,6)

 

元组的常用操作

索引

>>>ages = (1,2.3,4,5,6)

>>>ages[0]

1

>>>ages[-1]  #反过来索引，第一个位置

6

 

切片

同list

 

循环

for age in ages:

print(age)

 

长度

len（ages）

 

包含

1 in ages  #包含返回True，反则返回False

 

什么是字典

在{}内用逗号分隔，可以存放多个key:value的值，value可以是任意类型

定义：info={'name':'egon','age':18,'sex':18}    #info=dict({'name':'egon','age':18,'sex':18})

用于标识：存储多个值的情况，每个值都有唯一一个对应的key，可以更为方便高效地取值

字典是Python语言中唯一的映射类型

 

定义方式：{key1：value1，key2：value2}

1、键与值用冒号分开‘：’

2、项与项用逗号分开‘，’

 

字典特性：

1、key-value（键：值的结构）

2、key必须可hash，且必须为不可变数据类型，必须唯一

3、可存放任意多个值、可修改、可以不唯一

4、无序

 

字典的创建与常见操作

#字典的创建

person = {“name”:”alex”,”age”:20}

#或

person = dict(name='seven',age=20)

#或

person = dict({“name”:”egon”,'age':20})

#或

person = dict((['name','圆圆']，['文州'，18]))

 

注意：

>>>dic = {}.fromkeys(['k1','k2'],[]) #如果这里指定键但是不指定值，那么值的默认值就是空none

>>>dic {'k1':[],'k2':[]}

>>>dic['k1'].append(1)

>>>dic {'k1':[1],'k2':[1]}

 

字典的常见操作

键、值、键值对

1、dic.keys() 返回一个包含字典所有key的列表

2、dic.values() 返回一个包含字典所有value的列表

3、dic.items() 返回一个包含所有（键，值）元组的列表

4、dic.iteritems()、dic.iterkeys()、dic.itervalues()与它们对应的非迭代方法一样，不同的是它们返回一个迭代子，而不是一个列表

 

新增

dic[key] = value

dic.update('xxx)    #将括号中的所有元素添加到字典中，t可以是另一个集合，一个序列或者支持迭代的任意对象

{}.fromkeys(x,None)  #fromkeys() 函数用于创建一个新字典，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值   ---Python的语法解释

 

查找

1、dic.setdefault(key,None)  #查找字典中的key对应的值，如果字典中不存在key键，则新增这个键，默认None也可以指定，如果存在键则返回对应的值

2、dic.get(key(default=None))  #返回指定键的值，如果键不在字典中，返回一个指定值，默认为None，并不会添加

 

删除

1、dic.pop(key[,default])和get方法相似。如果字典中存在key，删除并返回key对应的value，如果key不存在，且没有给出default的值，则引发keyerror异常

2、dic.clear() 删除字典中的所有项或元素

3、del dic[key]

4、dic.popitem()   #Python 字典 popitem() 方法随机返回并删除字典中的一对键和值。如果字典已经为空，却调用了此方法，就报出KeyError异常

 

修改

1、dic['key'] = 'new_value' 如果key在字典中存在，‘new_value’将会替代原来的value值

2、dic.update(dic2) 将字典dic2的键值对添加到字典dic中

dic={'name':'egon','age':18}  

dic['age']=111   #如字典中存在，按照key来修改value的值

dic['sex']='male'  #如字典中不存在则新增

 

查看

1、dic['key'] 返回字典中key对应的值，若key不存在字典中，则报错

2、dict.get(key,default = None) 返回字典中key对应的值，若key不存在字典中，则返回default的值（default默认为None）

 

循环

1、for k in dic.keys()  #遍历字典中所有的键

2、for k,v in dic.items() #遍历字典所有键，值

3、for v in dic.values() #遍历字典中所有的值 

3、for k in dic  #遍历整个字典

按顺序遍历字典中的所有键for k in sorted(dic.keys()),使用函数sorted（）来获得按特定顺序排列的键列表的副本

如果字典中值很多，最终输出的列表含大量的重复项，使用（set）集合来剔除，for x in set(dic.values())

 

长度

len(dic) #查看字典长度

 

 

#3、成员运算in和not in :判断的是key
# dic={'name':'egon','age':18}
# print(18 in dic)
# print('age' in dic)

 

 

字典的嵌套

 

info={
    'name':'egon',
    'hobbies':['play','sleep'], 
    'company_info':{
        'name':'Oldboy',
        'type':'education',
        'emp_num':40,
    }
}
print(info['company_info']['name']) #取公司名


students=[
    {'name':'alex','age':38,'hobbies':['play','sleep']},
    {'name':'egon','age':18,'hobbies':['read','sleep']},
    {'name':'wupeiqi','age':58,'hobbies':['music','read','sleep']},
]
print(students[1]['hobbies'][1]) #取第二个学生的第二个爱好

字典、列表、元组的区别

字典用 { } 表示、列表用 [ ] 表示、元组用（） 表示

 

什么是集合

集合是一个数学概念：由一个或多个确定的元素所构成的整体叫做集合

集合中的元素有三个特征

1、确定性（元素必须可hash）

2、互异性（去重）

3、无序性（集合中的元素没有先后之分），如集合{3,4,5}和{3,4,5]算作同一个集合

PS：集合存在的意义就在于去重和关系运算

 

结合的用途

关系运算，去重

定义方式：在{}用逗号分割开多个元素,但是集合内元素的特点

 

去重的局限性:

被去重的元素必須是不可變類型

不能保證原來的顺序

 

in 和not in   #判断某元素是否在集合内

==和!=        #判断两个集合是否相等

PS：两个集合之间一般有三种关系，相交、包含、不想交。在Python中分别用下面的方法判断

set.isdisjoint(s):   #判断两个集合是不是相交

set.issuperset(s): #判断集合是不是包含其他集合，等同于a>=b

set.issubset(s):  #判断集合是不是被其他集合包含，等同于a<b

 

常用操作+内置的方法

 

长度   len(set)

 

合集（|）:取两个集合合并后的结果

A | B

A.union(B)

A.update(B)

 

交集（&）: 取两个集合共同的部分

A & B

A.intersection(B)

A.intersection_update(B)   #用于移除两个或更多集合中都不重叠的元素，即计算交集， intersection() 方法是返回一个新的集合，而 intersection_update() 方法是在原始的集合上移除不重叠的元素

 

差集（-）: 取存在于左(右)边结合但不存在与右面集合的元素

A - B)

A.difference(B)

 

对称差集（^）:例如:取没有同时在A和B中的值

(A - B) | (B - A)

A ^ B

A.symmetric_difference(B)

 

 

关系运算

==

s1={1,2,3}

s2={3,2,1}

print(s1 == s2)

 

父集：>=

子集：<=

s1={1,2,3,4}

s2={1,2,3}

print(s1 >= s2)

print(s1.issuperset(s2))   #issuperset() 方法用于判断指定集合的所有元素是否都包含在原始的集合中，如果是则返回 True，否则返回 False

print(s2.issubset(s1))      #issubset() 方法用于判断集合的所有元素是否都包含在指定集合中，如果是则返回 True，否则返回 False

 

集合類型其他内置方法(**)

s1={'a','b','c'，‘d’}

print(s1.pop())   #随机弹出一个值，类似于删除

s1.discard('d')     #discard() 方法用于移除指定的集合元素。该方法不同于 remove() 方法，因为 remove() 方法在移除一个不存在的元素时会发生错误，而 discard() 方法不会

 

s1.add('d')

print(s1)

s1={1,2,3}

s2={6,4,5}

print(s1.isdisjoint(s2))    #isdisjoint() 方法用于判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False

 

列表、元组、字典、集合的区别

列表：用[ ]表示，可修改

元组：元组和列表在结构上没有什么区别，唯一的差异在于元组是只读的，不能修改。元组用“()”表示

字典：字典定义了键和值之间一对一的关系,但它们是以无序的方式储存的。定义 Dictionary 使用一对大(花)括号“{ }”

集合：是一个无序不重复元素集, 基本功能包括关系测试和消除重复元素. 集合对象还支持union(联合), intersection(交), difference(差)和sysmmetric difference(对称差集)等数学运算.由于集合是无序的,所以，sets 不支持 索引, 分片, 或其它类序列（sequence-like）的操作

 

集合的常用操作

元素的增加 单个元素的增加add(),add的作用和类似列表中的append

对序列的增加update(),而update类似extend方法，update方法可以支持同时传入多个参数，传入时会把字符串拆分并无序排列

PS:由于集合有去重功能，所以update在传入多个参数时候会去除相同的参数,而数字是会顺序排列，字符串时随机排列

 

集合中元素的删除

元素的删除 set.discard(x)  #从set中删除指定的元素x，如果x不在set中，无任何反应

set.remove(x)   #从set中删除指定的元素x，如果x不在set中，则会报错Traceback

set.pop()      #从set中随机删除一个元素，如果set为空，则会报错Traceback

set.clear()    #将set中的所有元素清空

 

PS:可变类型：在id不变的情况下，value可以变，则称为可变类型，如列表，字典

PS: 不可变类型：value一旦改变，id也改变，则称为不可变类型（id变，意味着创建了新的内存空间），如元组