Python基础学习——字符串、列表、元组、字典、集合

　　Python中文学习大本营：http://www.pythondoc.com/ 

一、字符串操作

  一、用途：名字，性格，地址

name = 'wzs' #name = str('wzs')
print(id(name),type(name),name)

  二、优先掌握的

# 优先掌握的
切片 顾头不顾尾
msg='hello world'
##正向取值
print(msg[1:3])
print(msg[1:10:2])  #哪 到哪 步长
print(msg[:])
print(msg[::2])
#反向取值
print(msg[::-1])  #步长可以为负值
print([])
长度len
msg1 = 'qna ss'
print(len(msg1))

成员运算 in和not in
msg = 'hello world'
print('he' in msg)
print('ho' not in msg)

移除空白（默认去掉字符串两端的空格）strip
password = 'alex3714  '
##可以不做赋值操作
print(password.strip())
##去掉指定的字符
msg2 = '*******eg**on*****'
print(msg2.strip('*'))
msg3 = '  ****wzs  *****   '
print(msg3.strip(' |*'))

#切分split 指定分隔符(默认以空格为分隔符)
取出用户名
user_info = 'root:x:0:0:root:/root:/bin/bash'
# print(user_info[0:4])
print(user_info.split(':')[0]) #两个参数，以什么为分割和最多切割几次，默认有多少分割符，就切多少次
print(user_info.split(':',1)[0])  #以什么分割，分割多少次

  三、常规操作

# isdigit 用来判断字符中是否是由纯数字组成(bytes 或Unicode组成)

msg = '******alex****'
print(msg.strip('*'))
print(msg.lstrip('*'))
print(msg.rstrip('*'))

msg = 'my name is wzs,my age is 18'
print(msg.startswith('my'))  #以什么开头
print(msg.endswith('18'))   #以什么结尾

print(msg.replace('my','wzs',1))

#格式化输出
# 方式一
print('my name is %s,my age is %s' %('wzs',27))
# 方式二
print('my name is {},my age is {}'.format('wzs',27) )
# 方式三：打印指定位置的元素
print('{1} {0} {1}'.format('egon',18))
print('my name is {x},my age is {y}'.format(y=27,x='wzs'))

join连接
user_info = 'root:x:0:0:root:/root:/bin/bash'
l = user_info.split(':')
print(l) #以什么为分隔，以列表显示
print(':'.join(l)) #列表元素用什么连接
print(' '.join(l))

# center,ljust,rjust,zfill
print('wzs'.center(15,'='))  #center把前面的放在中间；总字符数量，其他的用‘=’填充
print('wzs'.ljust(15,'='))  #ljust 把前面的放在左边；总字符数量，其他的用‘=’填充
print('wzs'.rjust(15,'='))   #rjust 把前面的放在右边；总字符数量，其他的用‘=’填充
print('wzs'.zfill(15))  #zfill 把前面的放在右边；总字符数量，其他的用‘0’填充

  四、了解

find,rfind,index,rindex,count
# # find 查找
# msg = 'hello world'
# print(msg.find('ell'))  ##从左到右找，若有，则返回第一个字符的索引
# print(msg.find('ell33'))  ##从左到右找，若没有，则返回-1
# #index 索引
# print(msg.index('e',0,4)) #从左到右找（可以指定范围），若有，则返回返回第一个字符的索引
# # print(msg.index('ell33'))  ##从左到右找（可指定范围），若没有，则会报错  所以不要以index找元素
# # count 统计在某个范围（默认是整个范围）一个fa某个元素的数量
# print(msg.count('l',0,8))
#
# 设定tab空格的数量
# msg='abc	deft'
# print(msg.expandtabs(3))
#
# 字母数字判断
# 字母大小写转换
# msg='i am Chinese people'
# # msg = 'wzs112'
# print(msg.capitalize()) #首字母大写
# print(msg.upper()) #字母全转换成大写
# print(msg.lower())  #字母全转换成小写
# print(msg.title())  #单词首字母大写
# print(msg.swapcase())  #变量是否包含空格
#
# is系列
# msg='i am Chinese people'
# print(msg.isupper()) #是否全部大写
# print(msg.islower()) #是否全部小写
# print(msg.istitle()) #是否首字母大写
#
# 字母和数字
# msg='asasdf123'
# print(msg.isalnum()) #字符串是否由字母或数字组成
# msg = 'asdfasdf'
# print(msg.isalpha())  #字符串是否只有字母组成
#
# msg='   '
# print(msg.isspace())  ##是否只有空格
# msg='aaaai fabc'
# print(msg.isidentifier()) #标志符
#
# 判断数字
# age = 27
# inp = input('age>>: ').strip() #输入内容有空格，去掉
# if inp.isdigit():
#     inp=int(inp)
#     if inp > age:
#         print('ok')
# else:
#     print('必须输入数字')
#
num1=b'4' #bytes
num2=u'4' #unicode,python3中无需加u就是unicode
num3='四' #中文数字
num4='壹'
num5='Ⅳ' #罗马数字

# bytes,unicode
print(num1.isdigit())
print(num2.isdigit())
print(num3.isdigit())
print(num4.isdigit())
print(num5.isdigit())

# unicode
# print(num2.isdecimal())
# print(num3.isdecimal())
# print(num4.isdecimal())
# print(num5.isdecimal())

# unicode,汉字，罗马
# print(num2.isnumeric())
# print(num3.isnumeric())

二、列表操作

　　列表是最常用的数据类型之一，通过列表可以对数据实现方便的存储、修改的等操作

　　定义列表：fruits = [“’apple”,”orange“,”pear”,”banana”]

　　列表通过下标，访问数据，下标从0开始

  一、常规操作

students = ['wzs','alex','egon',11,['cyy','bjq']]

　　1、切片

 print(students[1:5])  

　　2、追加

  students.append('oldboy') 

　　3、插入

  students.insert(1,'alex') 

　　4、修改

students[2] = 'xiaoming'
print(students)

　　5、删除

del students[4] ##del是一种通用的删除方式
students.remove('egon')   ##remove按照值去删的，是单纯的删除，不会返回删除的值
print(students) 
students.pop()  #pop按照索引去删，默认从末尾（-1）开始删除
res = students.pop(1)
print(res)

　　6、取值

 print(students[2]) 

　　7、迭代 extend()方法

　　学习链接地址：https://www.cnblogs.com/wushuaishuai/p/7729011.html

  二、常规操作

students = ['wzs','alex','egon',11,['cyy','bjq']]
# 插入 指定位置插入值
students.insert(1,'alex')
#可以以列表的方式追加多个元素到原来列表的末尾
students.extend([1,34,5,6])
#统计列表某个元素的个数
print(students.count('alex'))
print(students)

  三、了解

students = ['wzs','alex','egon',11,['cyy','bjq']] 
# 清除列表
print(students.clear())

# 复制
l = students.copy()
print(l)

# 修改原列表，返回Node
# 反转 reverse()  #单纯的反转，将列表的索引顺序从倒过来
students.reverse()
print(students)
print(students.reverse())

# 不改变原列表，返回反转后的新列表（使用列表的切片实现）
l1=l[::-1]
print(l1)

#sort排序，默认是从小到的顺序
l=[2,44,-2,11,18]
# l.sort()
l.sort(reverse=True)  #从大到小的顺序排序元素
print(l)

  五、列表合并

　　1、使用“+”号

　　运算符的重载

l1=[1,2,3]
l2=[1212,"hello"]
l3=l1+l2
print(l3)

　　2、使用extend方法

　　方法比较简洁，但会覆盖原始list

l1.extend(l2)
print(l1)

　　3、使用切片进行合并

　　功能比较强大，可以将一个列表插入另一个列表的任意位置

　　　　以列表的长度切片合并，结果和前两种方法结果一样。在前面列表尾部插入列表。

l1[len(l1):len(l1)]=l2
print(l1)

　　　　在前面的开头插入列表

l1[0:0]=l2
print(l1)

　　　　也可以指定任意位置插入

l1[1:1]=l2
print(l1)

  六、练习

#队列 先进先出
# 使用apend
# l1=[]
# l1.append('first')
# l1.append('second')
# l1.append('third')
# print(l1)
# print(l1.pop(0))
# print(l1.pop(0))
# print(l1.pop(0))

#堆栈 先进后出
# print(l1.pop(-1))
# print(l1.pop(-1))
# print(l1.pop(-1))

#使用insert和pop
l2=[]
l2.insert(0,'four')
l2.insert(0,'five')
l2.insert(0,'six')
print(l2)
##堆栈 后进先出原则
# print(l2.pop(0))
# print(l2.pop(0))
# print(l2.pop(0))
##队列 先进先出原则
print(l2.pop(-1))
print(l2.pop(-1))
print(l2.pop(-1))

三、元组

　　作用：存多个值，对标列表来说，元组不可变（是可当作字典的key的），主要用来读

　　元组比列表更节省空间。

　　元组其实跟列表差不多，只是元组一旦创建，便不能再修改，所以又叫只读列表

　　定义元组：names = (“wzs”,"alex","egon")

　　只有两个方法，一个count，一个index

1 salary = (12000,18000,9000,36000)
2 # print(id(salary),type(salary),salary)

   一、优先掌握的操作

1 # 按索引取值(正向取+反向取)
2 print(salary[1])
3 # 切片
4 print(salary[:5:2])
5 #长度(元素的数量)
6 print(len(salary))
7 #成员运算 in和not in
8 print(12000 in salary)

  二、常规操作

1 # index 取索引所对应的值 索引存在，返回相对应的值；不存在报错
2 print(salary.index(12000))
3 # print(salary.index(120001))
4 #count  统计列表中元素的数量
5 print(salary.count(9000))

  三、数据取值操作 for和while循环

 1 #列表、字符串和元组通过索引取值，while循环;
 2 l1 = [12,45,11,66,112]
 3 index = 0
 4 while index < len(l1):
 5     # print(index)  #取索引
 6     print(index,l1[index]) #取索引和索引所对应的值
 7     index +=1
 8 
 9 # #使用for 循环
10 l = ['a','b','t','s','e']
11 #直接取值
12 for item in l:
13     print(item)
14 # 取索引
15 for item in range(len(l)):
16     print(item)

  四、练习

简单购物车,要求如下：
实现打印商品详细信息，用户输入商品名和购买个数，则将商品名，价格，购买个数加入购物列表，如果输入为空或其他非法输入则要求用户重新输入　　

msg_dic={
'apple':10,
'tesla':100000,
'mac':3000,
'lenovo':30000,
'chicken':10,
} 

 1 msg_dic={
 2 'apple':10,
 3 'tesla':100000,
 4 'mac':3000,
 5 'lenovo':30000,
 6 'chicken':10,
 7 }
 8 goods_l=[] ##定义购物车
 9 while True:
10     for key in msg_dic: #循环商品列表
11         print(key,msg_dic[key])
12     choice = input("你想购买什么：").strip() ##输入你自己需要的东西，去掉空字符串
13     if choice not in msg_dic:continue #在若你输入的东西不在字典中，停止这个循环，继续输入
14     count = input("个数>>:").strip()
15     if count.isdigit():#判断输入的必须是数字
16         goods_l.append((choice,msg_dic[choice],int(count)))   ##将用户输入信息追加到元组中
17         print(goods_l)

四、字典

　　作用：存多个值，key-value存取，取值速度快

　　定义：key必须是不可变类型，value可以是任意类型

　　语法：

info = {
    'stu001':"小明",
    'stu002':"小红",
    'stu003':"小亮",
}

  一、字典的特性：

　　　　1、字典是无序的

　　　　2、key必须是唯一的

  二、优先的操作：

1  info = {'name':'wzs','age':27,'sex':'male'}

　　1、增加

1 info['hobbies'] = ['running','reading','music']
2 print(info)

　　2、修改

  1 info['name']='alex' 2 print(info) 

　　3、删除

1 print(info.pop('name'))  #删除指定的key
2 print(info.pop('wzs',None)) #删除的key不存在，可自定义返回的内容（默认值是None）
3 print(info.popitem()) #删除的key不存在，可自定义返回的内容（默认值是None）
4 print(info)

　　4、查找

1 info2 = {'name':'wzs','age':20,'sex':'male'}
2 #取值get
3 # print(info2['name12']) ##直接使用key取值，key不在会报错
4 print(info2.get('name12','inexistent')) #使用get取值，存在会返回相应的值；不存在则返回自定义的值
5 print(info2.popitem())  #随机删除一个键值对

　　5、多级字典嵌套机操作

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

　　6、键值对的数量 len和成员运算

1 print(len(info))
2 # # 成员运算 in 和not in
3 print('name' in info) 

　　7、循环字典

1 for key in info.keys():
2     print(key)
3 for val in info.values():
4     print(val)
5 for item in info.items():
6     print(item) 

  三、常用的方法

setdefault的功能
1：key存在，则不赋值，key不存在则设置默认值
2：key存在，返回的是key对应的已有的值，key不存在，返回的则是要设置的默认值

1 #设定两个参数，分别传值
2 for k,v in info2.items():
3     print(k,v)
4 #设定空键值对
5 print(info2.setdefault('hobbbies',['reading','runnning']))  ##有则不改，返回已有的值；没有则新增，返回新增的值
6 print(info2)
7 #设定空置的键值对
8 print(info2.setdefault('hobbies',[]))
9 print(info2['hobbies'])

判断key是否在字典中，若不在，先创建空值键值对（值为列表），然后追加值到列表；若在的话，追加新值到列表中

 1 info3 = {'name':'wzs','age':20,'sex':'male'}
 2 #方式一
 3 if 'hobbies' not in info3:
 4     info3['hobbies'] = []
 5     info3['hobbies'].append('music')
 6 else:
 7     info3['hobbies'].append('read')
 8 #方式二
 9 info3.setdefault('hobbies',[]).append('music')
10 info3.setdefault('hobbies',[]).append('read')
11 print(info3)

  四、了解的操作

 1 ##update 新增字典的键值对：创建新的字典，使用update将新的字典里面的内容增加到原来的字典中
 2 info = {'name':'wzs','age':27,'sex':'male'}
 3 info_new = {'a':1,'b':16737}
 4 info.update(info_new)
 5 print(info)
 6 
 7 #创建初始化字典
 8 #新字典如下dic={'name':None,'age':None,'sex':None,'hobbies':None}
 9 dic_new = {}.fromkeys(['name','age','sex','hobbies'],None)
10 print(dic_new)

  五、扩展

　　1、有序字典类OrderedDict

　　https://www.cnblogs.com/zhenwei66/p/6596248.html

from collections import OrderedDict

　　2、Python中字典合并的四种方法

　　字典是Python语言中唯一的映射类型。字典是Python中最强大的数据类型之一。
　　映射类型对象里哈希值（键，key）和指向的对象（值，value）是一对多的的关系，通常被认为是可变的哈希表。
　　字典对象是可变的，它是一个容器类型，能存储任意个数的Python对象，其中也可包括其他容器类型。

　　　　1、字典类型与序列类型的区别：

1. 存取和访问数据的方式不同。
2. 序列类型只用数字类型的键（从序列的开始按数值顺序索引）；
3. 映射类型可以用其他对象类型作键（如：数字、字符串、元祖，一般用字符串作键），和序列类型的键不同，映射类型的键直4.接或间接地和存储数据值相关联。
4. 映射类型中的数据是无序排列的。这和序列类型是不一样的，序列类型是以数值序排列的。
5. 映射类型用键直接“映射”到值。

 　　　　2、具体的方法如下链接

　　https://blog.csdn.net/jerry_1126/article/details/73017270

　　3、其他

 1 # 1、链式赋值
 2 x=10
 3 y=x
 4 x=y=z=20
 5 print(id(x),id(y),id(z))
 6 #交换两个变量的值
 7 m = 10
 8 n = 20
 9 print(m,n)
10 m,n = n,m
11 print(m,n)
12 
13 # 从一个数据类型中解压出我们想要的值
14 t=(22,433,42,454,99)
15 a,b,c,d,e=t
16 # print(t)
17 # 支取自己想要的值
18 # a,_,_,_,e=t 
19 # print(a,e)
20 a,*_,e=t #等价于上面的
21 print(a,e)
22 
23 # 字典  只取出字典中的key
24 x,y,z={'a':1,'b':2,'c':3}
25 print(x,y,z)

  六、练习

1、有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中

即： {'k1': 大于66的所有值, 'k2': 小于66的所有值}

#1、设定一个空值列表的键值对字典，两个key；使用if判断，符合条件分别放到一个列表中
dic_num = {'k1':[],'k2':[]}
num = [11,22,33,44,55,66,77,88,99,90]
for i in num:
    if i > 66:
        dic_num['k1'].append(i)
    else:
        dic_num['k2'].append(i)
print(dic_num)

2 统计s='hello alex alex say hello sb sb'中每个单词的个数

结果如：{'hello': 2, 'alex': 2, 'say': 1, 'sb': 2}

for word in words:
    if word in dic:
        dic[word] +=1
    else:
        dic[word] =1
print(dic)

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

s = 'hello alex alex say hello sb sb'
dic = {}
words = s.split() ##将字符串空格为分隔，转换成列表形式
for word in words:
    dic[word]=s.count(word)
print(dic)

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

s = 'hello alex alex say hello sb sb'
dic = {}
words = s.split() ##将字符串空格为分隔，转换成列表形式
#使用setdefault设定字典的键值对
for word in words:
    dic.setdefault(word,s.count(word))
print(dic)

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

s = 'hello alex alex say hello sb sb'
dic = {}
words = s.split() ##将字符串空格为分隔，转换成列表形式
# print(words)
#使用集合去重，减少循环次数
words_set = set(words)
for word in words_set:
    dic[word]=s.count(word)
print(dic)

五、集合操作

　　集合是一个无序的，不重复的数据组合，他的主要作用是

1. 去重，把一个列表整合，就自动去重了
2. 关系测试，测试两组数据之前的交集、差集、并集等等

定义集合：
    集合：可以包含多个元素，用逗号隔开
    集合的元素遵循的三个原则：
        1、每个元素是不可变类型（可hash，可作为字典的key）
        2、没有重复的元素
        3、无序

  一、优先掌握的操作 

　　1、并集：|   交集：&  差集：-  对称差集：^

 1 pythons={'alex','egon','yuanhao','wupeiqi','gangdan','biubiu'}
 2 linuxs={'wupeiqi','oldboy','gangdan'}
 3 #| 并集
 4 # print(pythons | linuxs) #并集
 5 # print(pythons.union(linuxs))
 6 #& 交集
 7 # print(pythons & linuxs) #交集
 8 # print(pythons.intersection(linuxs))
 9 #- 差集
10 # print(pythons - linuxs)#差集
11 # print(pythons.difference(linuxs))
12 # print(linuxs - pythons)
13 #^ 对称差集
14 # print(pythons ^ linuxs) #对称差集
15 # print(pythons.symmetric_difference(linuxs))

　　2、> ， >= ， <, <= 父集，子集

 1 # s1={1,2,3,4}
 2 # s2={3,4,5}
 3 # print(len(s1) > len(s2))
 4 #
 5 s1={1,2,3,4}
 6 s2={3,4}
 7 # print(s1 > s2)
 8 print(s1.issubset(s2)) #子集
 9 print(s1.issuperset(s2)) #父集
10 # print(s1 >= s2)

　　3、去重

有列表l=['a','b',1,'a','a']，列表元素均为可hash类型，去重，得到新列表,且新列表无需保持列表原来的顺序

#列表去重。先转换为集合，去重结束，再转换成列表

方法一：下面的顺序是乱的

l=['a','b',1,'a','a']
l_new=list()
s=set()
for item in l:
    if item not in s:
        s.add(item)
        l_new.append(item)
print(s)

方法二：下面的方法是保持原来的顺序

1 l=['a','b',1,'a','a']
2 l_new=list()
3 s=set()
4 res=tuple(l)
5 for item in res:
6     if item not in s:
7         s.add(item)
8         l_new.append(item)
9 print(l_new)

有如下列表，列表元素为不可hash类型，去重，得到新列表，且新列表一定要保持列表原来的顺序

l=[
    {'name':'egon','age':18,'sex':'male'},
    {'name':'alex','age':73,'sex':'male'},
    {'name':'egon','age':20,'sex':'female'},
    {'name':'egon','age':18,'sex':'male'},
    {'name':'egon','age':18,'sex':'male'},
]　　

l=[
    {'name':'egon','age':18,'sex':'male'},
    {'name':'alex','age':73,'sex':'male'},
    {'name':'egon','age':20,'sex':'female'},
    {'name':'egon','age':18,'sex':'male'},
    {'name':'egon','age':18,'sex':'male'},
]
l_new = list()
s = set()
for item in l:
    res = (item['name'],item['age'],item['sex'])
    if res not in s:
        s.add(res)
        l_new.append(item)
print(l_new)

六、数据类型总结

  一、数据类型分类

　　1、按存储空间的占用分（从低到高）

数字
字符串
集合：无序，即无序存索引相关信息
元组：有序，需要存索引相关信息，不可变
列表：有序，需要存索引相关信息，可变，需要处理数据的增删改
字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改

　　2、按存值个数区分

标量／原子类型	数字，字符串
容器类型	列表，元组，字典

　　3、按可变不可变区分

可变	列表，字典
不可变	数字，字符串，元组

　　4、按访问顺序区分

直接访问	数字
顺序访问（序列类型）	字符串，列表，元组
key值访问（映射类型）	字典

  

七、字符编码与转码　　

　　字符编码与转码：http://www.cnblogs.com/linhaifeng/articles/5950339.html