Day2，Python基础

本章内容：
　　1.列表、元组操作

　　2.字符串操作

　　3.字典操作

　　4.集合操作

 

 

1.列表、元组操作：

列表就是一个数据的结合，结合内可以放任何数据类型，可对集合进行方便的增删改查操作

 

定义列表：

names = ['Alex',"Tenglan",'Eric']

 

通过下表访问列表中的元素，下标从0开始计数

>>> names[0]

'Alex'

>>> names[2]

'Eric'

>>> names[-1]

'Eric'

>>> names[-2] #还可以倒着取

'Tenglan'

 

切片：取多个元素

>>> names = ["Alex","Tenglan","Eric","Rain","Tom","Amy"]

>>> names[1:4]  #取下标1至下标4之间的数字，包括1，不包括4

['Tenglan', 'Eric', 'Rain']

>>> names[1:-1] #取下标1至-1的值，不包括-1

['Tenglan', 'Eric', 'Rain', 'Tom']

>>> names[0:3]

['Alex', 'Tenglan', 'Eric']

>>> names[:3] #如果是从头开始取，0可以忽略，跟上句效果一样

['Alex', 'Tenglan', 'Eric']

>>> names[3:] #如果想取最后一个，必须不能写-1，只能这么写

['Rain', 'Tom', 'Amy']

>>> names[3:-1] #这样-1就不会被包含了

['Rain', 'Tom']

>>> names[0::2] #后面的2是代表，每隔一个元素，就取一个

['Alex', 'Eric', 'Tom']

>>> names[::2] #和上句效果一样

['Alex', 'Eric', 'Tom']

 

追加： names.append("追加的内容")

>>> names

['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy']

>>> names.append("我是新来的")

>>> names

['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy', '我是新来的']

 

插入： names.insert(2,"在第二坐标插入")

>>> names

['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy', '我是新来的']

>>> names.insert(2,"强行从Eric前面插入")

>>> names

['Alex', 'Tenglan', '强行从Eric前面插入', 'Eric', 'Rain', 'Tom', 'Amy', '我是新来的']

 

>>> names.insert(5,"从eric后面插入试试新姿势")

>>> names

['Alex', 'Tenglan', '强行从Eric前面插入', 'Eric', 'Rain', '从eric后面插入试试新姿势', 'Tom', 'Amy', '我是新来的']

复制代码

 

修改：names[2] = "在第二坐标修改的内容"

>>> names

['Alex', 'Tenglan', '强行从Eric前面插入', 'Eric', 'Rain', '从eric后面插入试试新姿势', 'Tom', 'Amy', '我是新来的']

>>> names[2] = "该换人了"

>>> names

['Alex', 'Tenglan', '该换人了', 'Eric', 'Rain', '从eric后面插入试试新姿势', 'Tom', 'Amy', '我是新来的']

 

删除： 

del names[2]#通过坐标来删除   

names.remove("Eric") #删除指定元素  

names.pop() #删除列表最后的一个值和.remove很像

>>> del names[2]

>>> names

['Alex', 'Tenglan', 'Eric', 'Rain', '从eric后面插入试试新姿势', 'Tom', 'Amy', '我是新来的']

>>> del names[4]

>>> names

['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy', '我是新来的']

>>>

>>> names.remove("Eric") #删除指定元素

>>> names

['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy', '我是新来的']

>>> names.pop() #删除列表最后一个值

'我是新来的'

>>> names

['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy']

 

扩展： names.extend()

>>> names

['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy']

>>> b = [1,2,3]

>>> names.extend(b)

>>> names

['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy', 1, 2, 3]

 

拷贝：     四种浅copy 

1.name_copy = names.copy()   

2.name_copy = copy(names)                         

3.name_copy = names[:]              

4.name_copy = list(names) #工厂函数

 

深copy 

1.name_copy = copy.deepcopy(names)   #copy独立的个体

                            

     ====== 浅copy只copy列表的第二层 ======        

 

例子：

1.name_copy = names.copy()

import copy

names = ['Aelx','XiaoMao',['alex','aaa'],'XiaoGou','Love','Nito']

name_copy = names.copy()

print(names)

print(name_copy)

 

 2.name_copy = copy(names)

import copy

names = ['Aelx','XiaoMao',['alex','aaa'],'XiaoGou','Love','Nito']

name_copy = copy.copy(names)

print(names)

print(name_copy)

 

 3.name_copy = names[:]

import copy

names = ['Aelx','XiaoMao',['alex','aaa'],'XiaoGou','Love','Nito']

name_copy = names[:]

print(names)

print(name_copy)

 

  4.name_copy = list(names)  #工厂函数

import copy

names = ['Aelx','XiaoMao',['alex','aaa'],'XiaoGou','Love','Nito']

name_copy = list(names)

print(names)

print(name_copy)

 

拷贝例子：

import copy

names = ['Aelx','XiaoMao',['alex','aaa'],'XiaoGou','Love','Nito']

name_copy = copy.deepcopy(names)    #深copy

print(names)

print(name_copy)

 

 

len(列表名)  #获取列表的长度

 

 

统计：

>>> names

['Alex', 'Tenglan', 'Amy', 'Tom', 'Amy', 1, 2, 3]

>>> names.count("Amy")

2

 

排序&翻转：

>>> names

['Alex', 'Tenglan', 'Amy', 'Tom', 'Amy', 1, 2, 3]

>>> names.sort() #排序

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

TypeError: unorderable types: int() < str()   #3.0里不同数据类型不能放在一起排序了，擦

>>> names[-3] = '1'

>>> names[-2] = '2'

>>> names[-1] = '3'

>>> names

['Alex', 'Amy', 'Amy', 'Tenglan', 'Tom', '1', '2', '3']

>>> names.sort()

>>> names

['1', '2', '3', 'Alex', 'Amy', 'Amy', 'Tenglan', 'Tom']

 

>>> names.reverse() #反转

>>> names

['Tom', 'Tenglan', 'Amy', 'Amy', 'Alex', '3', '2', '1']

 

获取下标：

>>> names

['Tom', 'Tenglan', 'Amy', 'Amy', 'Alex', '3', '2', '1']

>>> names.index("Amy")

2 #只返回找到的第一个下标

 

 

元组  别名（只读列表）

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

 

语法：

names = ("alex","jack","eric")

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

 

2.字符串的操作：

字符串是一个有序的字符的集合，用于存储和表示基本的文件信息，一对单、双、或 三引号中间包含的内容称之为字符串

 

创建：

        s = 'Hello,aaa! How are you?'

特性：

1.有序

2.不可变

补充：

1.字符串的单引号和双引号都无法取消特殊字符的含义，如果想让引号内所有字符均取消特殊意义，在引号前面加r，如name＝r'l\thf'

2.unicode字符串与r连用必需在r前面，如name＝ur'l\thf'

 

常用操作：

#索引

s = 'hello'

>>> s[1]

'e'

>>> s[-1]

'o'

>>> s.index('e')

1

 

#查找

>>> s.find('e')

1

>>> s.find('i')

-1

 

 

#移除空白

s = '  hello,world!  '

s.strip()

s.lstrip()

s.rstrip()

s2 = '***hello,world!***'

s2.strip('*')

 

#长度

>>> s = 'hello,world'

>>> len(s)

11

 

#替换

>>> s = 'hello world'

>>> s.replace('h','H')

'Hello world'

>>> s2 = 'hi，how are you？'

>>> s2.replace('h','H')

'Hi，How are you？'

 

#切片

>>> s = 'abcdefghigklmn'

>>> s[0:7]

'abcdefg'

>>> s[7:14]

'higklmn'

>>> s[:7]

'abcdefg'

>>> s[7:]

'higklmn'

>>> s[:]

'abcdefghigklmn'

>>> s[0:7:2]

'aceg'

>>> s[7:14:3]

'hkn'

>>> s[::2]

'acegikm'

>>> s[::-1]

'nmlkgihgfedcba'

 

字符串类型：

replace语法

replace()方法语法：方法把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次。

str.replace(old, new[, max])

参数

• old -- 将被替换的子字符串。
• new -- 新字符串，用于替换old子字符串。
• max -- 可选字符串, 替换不超过 max 次

返回值

返回字符串中的 old（旧字符串） 替换成 new(新字符串)后生成的新字符串，如果指定第三个参数max，则替换不超过 max 次。

 

find语法

find()方法语法：检测字符串中是否包含子字符串

str.find(str, beg=0, end=len(string))

参数

• str -- 指定检索的字符串
• beg -- 开始索引，默认为0。
• end -- 结束索引，默认为字符串的长度。

返回值

如果包含子字符串返回开始的索引值，否则返回-1。

 

isdigit语法

isdigit()方法语法：方法检测字符串是否只由数字组成。

str.isdigit()

 

replace() 方法把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次。Find

 

count语法

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

str.count(sub, start= 0,end=len(string))

参数

• sub -- 搜索的子字符串
• start -- 字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0。
• end -- 字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置。

 

strip语法

strip()方法语法：用于移除字符串头尾指定的字符（默认为空格）。

str.strip([chars]);

参数

• chars -- 移除字符串头尾指定的字符。

 

center语法

center()方法语法：方法返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。

str.center(width[, fillchar])

参数

• width -- 字符串的总宽度。
• fillchar -- 填充字符。

返回值

返回一个指定的宽度 width 居中的字符串，如果 width 小于字符串宽度直接返回字符串，否则使用 fillchar 去填充。

 

 

split语法

split()方法语法：通过指定分隔符对字符串进行切片，如果参数num 有指定值，则仅分隔 num 个子字符串

str.split(str="", num=string.count(str))

参数

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

返回值

返回分割后的字符串列表。

 

 

join语法

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

 

str.join(sequence)

参数

• sequence -- 要连接的元素序列。

返回值

返回通过指定字符连接序列中元素后生成的新字符串。

实例

以下实例展示了join()的使用方法：

#!/usr/bin/python3

 

s1 = "-"

s2 = ""

seq = ("r", "u", "n", "o", "o", "b") # 字符串序列

print (s1.join( seq ))

print (s2.join( seq ))

 

以上实例输出结果如下：

r-u-n-o-o-b

runoob

 

chr语法

以下是 chr() 方法的语法: ASCLL字符集对应数字编码

chr(i)

参数

• i -- 可以是10进制也可以是16进制的形式的数字。

返回值

返回值是当前整数对应的ascii字符。

 

 

3.字典操作：

字典一种key-value的数据类型，使用就像我们上学用的字典，通过笔画、字母来查对应页的详细内容。

特性：

1.key-value结构

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

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

4.无序

5.查找速度快

 

语法：

 

info = {

'stu1101': "TengLan Wu",

'stu1102': "LongZe Loula",

'stu1103': "Xiaoze Maliya",

}

 

print(info)

 

=== 增加&修改：

 

info["stu1101"] = "武藤兰"   #更改key

info["stu1104"] = "CangJingKong"   #如果存在将修改，不存在将添加

 

=== 删除：

 

del info["stu1101"]

info.pop("stu1102")

info.popitem()   #随机删除

 

 

=== 查找：

 

print(info["stu1101"])  #查找 没有删除内容会报错

 

print(info.get('stu1103'))

 

print('stu1103' in info)  #判断这个值是否存在  存在为True,

 

 

=== 多级字典嵌套及操作：

 

av_catalog = {

    "欧美":{

        "www.youporn.com": ["很多免费的,世界最大的","质量一般"],

        "www.pornhub.com": ["很多免费的,也很大","质量比yourporn高点"],

        "letmedothistoyou.com": ["多是自拍,高质量图片很多","资源不多,更新慢"],

        "x-art.com":["质量很高,真的很高","全部收费,屌比请绕过"]

    },

    "日韩":{

        "tokyo-hot":["质量怎样不清楚,个人已经不喜欢日韩范了","听说是收费的"]

    },

    "大陆":{

        "1024":["全部免费,真好,好人一生平安","服务器在国外,慢"]

    }

}

 

=== 更改：

av_catalog["大陆"]["1024"][1] += ",可以做镜像"   #更改一个值

print(av_catalog["大陆"]["1024"])

 

av_catalog.setdefault("taiwan",{"www.baidu.com":[1,2]})  #创建一个新的值 ,如果这个值存在将不创建

print(av_catalog)

 

values： 把所有的值打出来

print(av_catalog.values())

 

keys：  打印key

print(av_catalog.keys())

 

 

 

=== update更新：

info = {

'stu1101': "TengLan Wu",

'stu1102': "LongZe Loula",

'stu1103': "Xiaoze Maliya",

}

 

b ={

    'stu1101': "Alex",

    1:3,

    2:5

}

info.update(b)  #更新  如果合并的内容有相同的key，将会覆盖原来的key

print(info)

 

=== key转列表

print(info.items())  #key转列表

 

 

=== 初始化新的字典

 

c = dict.fromkeys([6,7,8])   #初始化新的字典，key已经写好了。

print(c)

 

c = dict.fromkeys([6,7,8],[1,{"name":"alex"},444])  #创建一个列表跟着改

print(c)

 

c[7][1]['name'] = "Jack Chen"   #改一个值，都会跟着改

print(c)

 

 

=== for循环字典

 

for key in info:

    print(key)  #打印key

    print(key,info[key])    #打印key和values    建议用这种方式

 

for k,v in info.items():    #打印key和values

    print(k,v)

 

字典是无须的，没有序号。  用key来查询 key必须是唯一的，天生去重。

 

4.集合操作

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

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

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

 

常用功能：

list_1 = [ 1,3,4,6,9,66 ]

list_1 = set(list_1)

 

list_2 = set([0,2,4,5,6,22])

print(list_1,list_2)

 

#交集   两个集合相同的提出来

print(list_1.intersection(list_2))

print(list_1 & list_2)

 

#并集   两个集合合并，去重

print(list_1.union(list_2))

print(list_1 | list_2)

 

#差集  

print(list_1.difference(list_2))

print(list_2.difference(list_1))

print(list_1 - list_2) #(项在list_1，中不在list_2中)

 

#子集

list_3 = set([1,3,7])

print(list_3.issubset(list_1))  #判断集合是不是包含了其它集合，等于a>=b

print(list_1.issuperset(list_3)) #判断集合是不是被其他集合包含，等于a<=b

 

#对称差集  把不交集的取出来 和交集相反

print(list_1.symmetric_difference(list_2))

print(list_1 ^ list_2)

 

print("--------")

 

#没交集显示真（True）,有交集显示假(False)

list_4 = set([2,4,8])

print(list_3.isdisjoint(list_4))  #判断两个集合石不是不想交

 

#添加集合

list_1.add(999)  #只能添加一个值

list_1.update([888,777,666])  #可以添加多个值

print(list_1)

 

#使用remove删除一项

list_1.remove('999')

print(list_1.pop())  #随机删除 返回删除的值

list_1.discard() #remove 删除不存在会报错，discard不会

 

 

#测试 list_1 是否是list_2的成员

list_1 in list_2

 

#测试 list_1 是否不是list_2的成员

list_1 in not list_2