目录

字符串String

字符串声明

 防止字符串转义

反向索引

 字符串的拼接

列表List

 列表声明

元组Tuple

元组的声明

元组的不可变性 

字典Dictory

字典的声明 

 字典的访问（通过键来访问）

字典的新增和删除

集合Set

集合的声明

set底层存储 

set增删改

集合的运算（交并差…）

集合应用：列表去重

字符串String

字符串声明

字符串的定义：

Python中的字符串可以使用单引号，双引号和三引号（三个单引号或三个双引号）括起来作为定义方式。

字符串的定义:
str1 = 'String...'
str2 = "String..."
str3 = """String..."""
str4 = '''String...'''

值得注意的是，当使用三个引号时可以保留段落格式，例如：

str3 = """你好Tom
  我是Jerry！

"""

输出为：

 防止字符串转义

路径使用单斜杠”\”时，会被解释器解释成转义。所以需要使用”\\”

#错误写法:
location = "d\temp\hello.text"
#正确写法:
location1 = "d\\temp\\hello.text"

反向索引

str = "abcdefg"
# 正向索引:0 1 2 3...
print(str[0]) #a
print(str[1])#b

#反向索引:-7 -6 -5...
print(str[-1])#g
print(str[-2])#f

 字符串的拼接

#拼接方式1
str = "abc"
str1 = "def"
str += str1
print(str)#abcdef
#拼接方式2
str2 = "aa"
str3 = "bb"
print(str2 + str3)#aabb

列表List

1.列表中可以存放数值，字符串，列表等。

2.列表的使用[ ]声明，内部元素间使用逗号分隔。

3.列表通过索引访问，索引从0开始。

4.列表可以使用” + “号进行拼接。

 列表声明

方式1：基本方式

li = list[1,'a']
li1 = list[2,'b',li]
print(li1)#list[2, 'b', list[1, 'a']]

方式2：通过list()方法

li = list("我是列表")
print(li)#['我', '是', '列', '表']
li1 = list(range(1,6))
print(li1)#[1, 2, 3, 4, 5]

元组Tuple

1.元组和列表类似，但是元组中的元素是不能修改的。

2.元组定义在小括号()内，元素之间用逗号隔开。

需要注意的是:当定义的元组只有一个元素时，后面需要加一个逗号。

例如：tup = (‘a’,)

元组的声明

# 基本方式
tup1 = (1,2,'a')
#特殊格式声明
tup2 = 1,2,'a'
print(tup1)#(1, 2, 'a')
print(tup2)#(1, 2, 'a')

元组的不可变性 

元组不可修改(增删改)，通过索引遍历，

不支持删除元素，只支持删除整个元组。

# 不可变性说明
tup1 = (1,2,'a')
print(id(tup1))#1915378310848

tup1 = (1,2,3)
print(id(tup1))#1915374761920

可以发现两者存储空间不同
重新给tup1赋值实际上是新开辟了一块内存空间

元组的元素是不可以修改，但是元组内如果存在列表等可变元素，这样的列表元素可以修改。

字典Dictory

1.字典是无序的集合，使用键值对方式存储。

2.key-balue中，key应该为不可变类型，且key值唯一。

字典的声明 

dict = {"name":"Tom","age":18}
print(dict)#{'name': 'Tom', 'age': 18}

 字典的访问（通过键来访问）

通过key值访问

此方式访问时，当输入了不存在的key，会报错。

dict = {"name":"Tom","age":18}
print(dict["name"])#Tom
# print(dict["hobby"])#报错

通过.get()的方式访问

此方式访问时，当输入了不存在的key，不会报错，返回None。

dict = {"name":"Tom","age":18}
print(dict.get("name"))#Tom
print(dict.get("hobby"))#None

#当没有找到时，自定义输出
print(dict.get("hobby","basketball"))#basketball

字典的新增和删除

新增

dict = {"name":"Tom","age":18}
dict["hobby"] = "sleep"
print(dict)#{'name': 'Tom', 'age': 18, 'hobby': 'sleep'}

删除del

dict = {"name":"Tom","age":18}
dict["hobby"] = "sleep"
print(dict)#{'name': 'Tom', 'age': 18, 'hobby': 'sleep'}
del dict["hobby"]
print(dict)#{'name': 'Tom', 'age': 18}

集合Set

1.set和dic类似，也是一组key-value的集合，但是set不存储value。

2.集合set中的key不能重复。并且是存储是无序的。

集合的声明

基本声明方式

s1 = {1,2,2}
print(type(s1))#<class 'set'>

空集合的声明

se = set()
print(type(s1))#<class 'set'>

set底层存储 

集合特点：set 不可重复，存储元素需不可变，底层存储无序性。

底层无序性说明：set的无序性不等于随机性，无序性说的是set不能向列表那样，通过索引的方式获取。

存储过程：set存储元素时，先计算出元素的哈希值，然后哈希值通过某种算法计算出底层存储的位置，判断该位置是否存在元素，存在则对比哈希值，哈希值不相同，添加成功，哈希值相同，再比较元素是否相同。元素不相同添加成功，元素相同，添加失败。

set增删改

增加add（）

s1 = {1,2,2}
s1.add(4)
print(s1)#{1, 2, 4}

添加多个值：添加序列update(）

s1 = {1,2,2}
s1.update("abc")
print(s1)#{1, 2, 'b', 'c', 'a'}

删除clear，remove，pop和discard

clear

s1 = {1,2,2}
s1.update("abc")
print(s1)#{1, 2, 'b', 'c', 'a'}

s1.clear()
print(s1)#set()

remove

s1 = {1,2,2}
s1.update("abc")
print(s1)#{1, 2, 'b', 'c', 'a'}

s1.remove(1)
print(s1)#{'a', 2, 'b', 'c'}
s1.remove('s')#删除不存在的元素时报错

pop

pop：删除最后一个元素，但是set存在无序性，最后一个元素不可控。

s1 = {1,2,2}
s1.update("abc")
print(s1)#{1, 2, 'b', 'a', 'c'}

s1.pop()
print(s1)#{2, 'b', 'a', 'c'}

discard：解决删除不存在的元素时报错的问题

对remove方法的完善：元素不存在，默默结束。

s1 = {1,2,2}
s1.update("abc")
print(s1)#{1, 2, 'b', 'c', 'a'}

s1.discard(1)
s1.discard('s')#删除不存在的元素
print(s1)#{2, 'b', 'c', 'a'}

set改

改：表面意义上的”改”，因为集合元素为不可变元素，要执行改操作，

        相当于是删除掉一个元素，在添加一个元素。

s1 = {1,2,2}
s1.update("abc")
print(s1)#{1, 2, 'b', 'c', 'a'}

s1.remove("a")
s1.add("s")
print(s1)#{'s', 1, 2, 'b', 'c'}

set特殊的查询操作—>in— ont in

s1 = {1,2,2}
s1.update("abc")
print(s1)#{1, 2, 'b', 'c', 'a'}

logo = "a" in s1
print(logo)#True

logo = "a" not in s1
print(logo)#False

集合的运算（交并差…）

交集intersection

----方式1----
set1 = {1,2,3}
set2 = {1,2,3,4,5}
res = set1 & set2
print(res)#{1, 2, 3}

-----方式2-----
set1 = {1,2,3}
set2 = {1,2,3,4,5}
res = set1.intersection(set2)
print(res)#{1, 2, 3}

并集union

-----方式1-----
set1 = {1,2,3}
set2 = {1,2,3,4,5}
res = set1 | set2
print(res)#{1, 2, 3, 4, 5}
-----方式2-----
set1 = {1,2,3}
set2 = {1,2,3,4,5}
res = set1.union(set2)
print(res)#{1, 2, 3, 4, 5}

差集difference

set1 = {1,2,3,7}
set2 = {1,2,3,4,5}
res = set2 - set1
print(res)#{4, 5}
ress = set1 - set2
print(ress)#{7}

异或symmetric_difference

---------方式1----------
set1 = {1,2,3,7}
set2 = {1,2,3,4,5}
res = set1 ^ set2
print(res)#{4, 5, 7}
---------方式2----------
set1 = {1,2,3,7}
set2 = {1,2,3,4,5}
res = set1.symmetric_difference(set2)
print(res)#{4, 5, 7}

子集issubset()

----子集------
set1 = {1,2,3}
set2 = {1,2,3,4,5}
res = set1 <= set2
print(res)#True


-----issubset---
set1 = {1,2,3}
set2 = {1,2,3,4,5}
res = set1.issubset(set2)
print(res)#True

-----超集-----
set1 = {1,2,3}
set2 = {1,2,3,4,5}
res = set2 >= set1
print(res)#True

集合应用：列表去重

lis = [1,2,2,3,6,6,4,5,1]
temp = set(lis)
res = list(temp)
print(res)#[1, 2, 3, 4, 5, 6]
print(type(res))#<class 'list'>