【python课程学习2-2】——列表、元祖、字符串、字典

@主要对列表、元组、字符串、字典的基本操作进行总结。～～～奥利给～～～

三、列表

3.1 列表基本操作

（1）列表基本操作：包括列表中值的增、删、改、查（切片）

names = ["1user1",'2user2','3user6',"4user3",'5user4','6user5','7user6']

#列表值的查询操作，也叫切片，
names[2],names[1:4],names[-3:-1]
names[1:4] #注意切片时，是顾首不顾尾，即不会把索引4的位置计算进去
names[-3:-1] #注意切片时，是从左边开始的。
names[-3:]  #不写-1可直接取到最后一个，0和-1可省略不写，但是一般都写
names.index('user6',0,7) #注意：找的是列表中某个元素的第一个匹配项的索引

#列表值的增加操作
names.append("user88") #直接在列表后面增加
names.insert(2,"user2_1") #插入到指定位置
names.extend(list1) #把list1拓展到names中来

#列表值的删除操作，三种方式
names.remove("user6") #可以直接用value进行删除,注意：移除列表中某个元素的第一个匹配项
names.pop(-3) #指定索引进行删除，不填写时默认为-1
del names[0]
names.clear() #清空列表

#删除列表，删除变量
del names 

#列表值的修改操作
names[1] = "jxx"

#列表的清空并删除该变量
names.count("user6") #通过value直接统计相同元素个数
names.reverse() #反转列表
names.sort() #根据ASCII码进行的排序

（2）列表的列表数据以单个元素方式添加到列表中。
方式就是：
list1[1:1] = list2

l1 = [1,3,4]
l2 = [33,56,66,7]

l1.append(l2)
print(l1,'append的合并')

l1.extend(l2)
print(l1,'extend的合并')

l1[1:1] = l2
print(l1,'列表中的元素作为单个元素的合并')

运行结果

[1, 3, 4, [33, 56, 66, 7]] append的合并
[1, 3, 4, [33, 56, 66, 7], 33, 56, 66, 7] extend的合并
[1, 33, 56, 66, 7, 3, 4, [33, 56, 66, 7], 33, 56, 66, 7] 列表中的元素作为单个元素的合并

3.2 列表的浅copy和深copy

列表中list.copy() 的特殊解释
首先，在字符串和整型数据中，a复制b，a有修改，且b不会有改动，这是深copy，例如：

a = 1
b = a
a = 2
print(a)  #a=2
print(b)  #b=1 b没有变化，这是深copy

其次，在列表中的copy ,list1和list2的copy ，如果list2复制list1，list1有变动，则list2会有变动，属于浅copy。

浅copy的作用是可以复制一条和上条相同的内容，且修改list1后，list2的相关数据也会改变，例如一个家庭的银行资金，一个人花了一部分，则另一的账户也会减少的相对减少，就会直接同步。直接看例子

import copy
#家庭人员1和2，家庭的钱是共用的
home_person = ['name',['money',100]]

'''
#三种创建浅copy的方法
p1 = copy.copy(home_person)
p2 = home_person[:] #省略了0和-1，也就是从0到-1进行复制
p3 = list(home_person)
'''

#使用浅copy的方法，创建家庭人员1和人员2
person1 = home_person[:]
person2 = home_person[:]
person1[0] = "小贾"
person2[0] = "大甄"
print(person1)
print(person2)

#浅copy，money正好也跟着变化
person1[1][1] = 80
print(person1)
print(person2)

运行结果如下：

那么如何做到list1有变动，则list2不变，即是深copy，则导入模块copy，使用copy.deepcopy()方法即可。虽然在实际中不需要或者很少用深复制。

names = ["1user1",'2user2','3user6',["xiaoJIA","QW"],"4user3",'5user4','6user5','7user6']
name_copy = names.copy()
print(names,"__________原始的names ")
print(name_copy,"________第一次copy——names的name_copy 没有改变值 ")

names[1] = "修改部分浅"
print(names,"__________修改原始的names数据 ")
print(name_copy,"__________仍然浅copy——names的name_copy 没有改变值")

names[3][1] = "小贾"
print(names,"__________修改原始中列表的值的names数据 ")
print(name_copy,"__________仍然浅copy——names的name_copy 并且跟着改变了值，")
print("就是name_copy跟着names改变了值，没有做到copy names第一次的值就算浅copy,是不是浅copy是以names为参考的，")

3.3 列表的循环

可以进行切片式的循环，获取想要的内容

names = ["1user1",'2user2','3user6',["xiaoJIA","QW"],"4user3"]

for i in names:
    print(i)

for i in names[0:-1:2]:
    print("@@",i)

运行结果如下：

1user1
2user2
3user6
['xiaoJIA', 'QW']
4user3
@@ 1user1
@@ 3user6

四、元组

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

语法：
names = (“name1”,“name2”,“name3”)

它只有2个方法，一个是count，一个是index。

五、字符串

5.1 字符串大小写转换：5个

str = 'hello,woRld!'
str.capitalize()  #仅首字母大写，Hello,world!
str.title()       #仅每个单词首字母大写，Hello,World!
str.upper()       #每个字母都大写，HELLO,WORLD!
str.lower()       #每个字母都小写，hello,world!
str.swapcase()    #大小写转换，HELLO,WOrLD!

5.2 字符串内容判断：8个

num = '123'
alp = 'asd'
num_alp = 'als2d'
num.isdigit()      #字符串中的字符是否都是数字，True
alp.isalpha()      #字符串中的字符是否都是字母，True
num_alp.isalnum()  #字符串中的字符是否都是数字和字母，True
num.isnumeric()    #字符串中的字符是否都是数字，True
alp.islower()      #字符串中的字符是否都是小写字母，True
num_alp.isupper()  #字符串中的字符是否都是大写字母，True
alp.istitle()      #字符串中的字符是否形如标题Hello,World，False
' '.isspace()      #字符串中的字符是否都是空格，True

5.3 字符串填充：4个

str = 'Welcome'
str.center(13,'*')  #***Welcome***
str.ljust(10,'+')   #Welcome+++
str.rjust(10,'-')   #---Welcome
str.zfill(10)       #000Welcome
'-100'.zfill(10)    #-000000100
'+100'.zfill(10)    #+000000100 主要在数字前面加入0，对进制补零特别有用

5.4 字符串搜索：3个

str='awasdhiwhhihuasd~hjdsasdihfi'
str.find('asd')   #str中有子字符串时会返回首字母所在索引值，若不存在则报错error
str.index('asd')  #str中有子字符串时会返回首字母所在索引值，若不存在则返回-1
str.count('asd')  #返回字符串中包含的子串个数，若不存在则返回0

5.5 字符串添加：join()方法

join() 方法：用于将序列中的元素以指定的字符连接生成一个新的字符串

用法：str.join(seq) 其中seq包括字符串、列表、元祖、集合、字典（字典仅连接key）。

 注意：其中列表、元祖和集合的元素都必须是字符串，否则会报错

list=['I','am','IronMan！']
' '.join(list)            #I am IronMan!
'*'.join({'6','4','78'})  #6*78*4  注意：集合的每次结果都是无序的，就是排位不一样
'-'.join('ABCD')          #A-B-C-D
'+'.join(('a','b','c'))   #a+b+c
'~'.join({'a':1,'b':2})   #a~b

5.6 字符串修剪：strip()方法

strip()方法，用于移除字符串头尾指定的字符（默认空格和换行符）或字符序列.

   注意：该方法只能删除开头或是结尾的字符，不能删除中间部分的字符。

str1 = "00000003210Runoob01230000000"
str1.strip( '0' );         # 去除首尾字符0 返回结果：3210Runoob0123
str2 = "   Runoob      "   # 去除首尾空格  返回结果：Runoob
str2.strip()

5.7 字符串切割：split()方法

Python split() 通过指定分隔符对字符串进行切片，如果参数 num 有指定值，则分隔 num+1 个子字符串

split() 方法语法：
str.split(str="", num=string.count(str)).

参数
str – 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。
num – 分割次数。默认为 -1, 即分隔所有。

str = "this is string example"
str.split(' ')  #以空格为分割符进行切片，并以列表的形式返回  
                # 返回结果：['this', 'is', 'string']

六、字典

6.1 字典的特性

字典是一种key-value的数据类型，通过key来查找对应的value。
字典的特性：
～dict是无序的
～key必须是唯一的，所以是天生去重

注意：

每个键与值用冒号隔开（:），每对用逗号，每对用逗号分割，整体放在花括号中（{}）。

～键必须不可变，所以可以用数，字符串或元组充当，所以用列表就不行；

～但值则不必，值可以取任何数据类型，但必须是不可变的，如字符串，数或元组。

6.2 字典：增加

dict = {
    'user1':'jia-1',
    'user2':'jia-2',
    'user3':'jia-3',
    1:33,
    4:55
}
#初始化一个字典，并把不同的key值，赋予相同的value
dict1 = dict.fromkeys([3,4,5],{'beijing':'come on'})
print(dict1)

6.3 字典：修改

dict['user1'] = 'JIA-1'     #已有的key值将会修改value
dict['user88'] = 'JIA-566'  #之前没有此key值，将会新添加一个键值对

6.4 字典：删除

能删单一的元素也能清空字典，清空只需一项操作。
显示删除一个字典用del命令，如下实例：

del dict          #删除词典
del dict[key]     #删除键是key的条目
dict.pop(key)     #注意：如果是整型的话，不要加引号
dict.clear()      #清空词典所有条目，变成一个空字典
dict.popitem()    #随机返回并删除字典中的一对键和值

此处的随机其实是假的，正如列表的 pop() 方法总是删除列表中最后一个元素，实际上字典的 popitem() 其实也是删除字典中最后一个 key-value 对。由于字典存储 key-value 对的顺序是不可知的，因此开发者感觉字典的 popitem() 方法是“随机”删除的，但实际上字典的 popitem() 方法总是删除底层存储的最后一个 key-value 对。

6.4 字典：查找

dict.get(key, default=None)    #返回指定键的值，如果值不在字典中返回default值
dict.items()    #以列表返回可遍历的元组数组，即返回一个列表，列表中的元素是元祖，元祖值（key,value）
dict.keys()       #以列表返回一个字典所有的键
dict.values()     #以列表返回字典中的所有值

6.5 字典内置函数&方法

（1）Python字典包含了以下内置函数：

cmp(dict1, dict2)      #比较两个字典元素。
len(dict)              #计算字典元素个数，即键的总数。
str(dict)              #输出字典可打印的字符串表示。
type(variable)         #返回输入的变量类型，如果变量是字典就返回字典类型。

（2）Python字典包含了以下内置方法：

dict.clear()        #删除字典内所有元素
dict.keys()         #以列表返回一个字典所有的键
dict.values()       #以列表返回字典中的所有值
dict.copy()         #返回一个字典的浅复制
dict.update(dict2)  #把字典dict2的键/值对更新到dict里,即合并起来，key已有的替换，没有的新增
dict.items()        #以列表返回可遍历的元组数组，即返回一个列表，列表中的元素是元祖，元祖值（key,value）
dict.fromkeys()     #创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
dict.get(key, default=None)        #返回指定键的值，如果值不在字典中返回default值
dict.setdefault(key, default=None) #和get()类似, 但如果键不已经存在于字典中，将会添加键并将值设为default

6.6 字典的循环

方式一：更高效，更快，建议用这个。

方式二：还需要把字典转为列表，数据量大的时候非常浪费时间。

#方式一
for i in dict:
    print(i,dict[i])
    
#方式二
for k,v dict.items():
    print(k,v)