Python3_Day02_数据类型

一、数字

int()方法

int()方法可字符串类型转换为数字类型，字符串必须为一串数字

• 举例：

a = "123"
b = int(a)
print(b + 100)

运行结果：

223

二、字符串

在 Python 中字符串支持加法和乘发的运算

• 举例：

n1 = "a"
n2 = "b"
print(n1 + n2)
print(n1 * 2)

运行结果：

ab

aa

1、replace：对字符串中指定的字符进行替换

s01 = "abcabc"
print(s01.replace("a", "A"))

运行结果：

AbcAbc

2、find：查找某一个字符在字符串中的位置索引

s02 = "abcabc"
print(s02.find("a"))

运行结果：

0

3、join：指定分隔符对字符串进行分割

s03 = "abc"
print(" ".join(s03))

运行结果：

a b c

4、strip：删除字符串两边的空格或换行符，可指定删除的内容

s04 = "%%%%abc%%%%"
print(s04)
print(s04.strip("%"))
print(s04.rstrip("%"))
print(s04.lstrip("%"))

运行结果：

%%%%abc%%%%

abc

%%%%abc

abc%%%%

5、startswith：检查字符串是否以指定的字符开头

s05 = "Abc"
print(s05.startswith("A"))
print(s05.startswith("a"))

运行结果：

True

False

6、split：指定分割符对字符串进行分割，可指定分割的次数

s06 = "a b c d e"
print(s06.split(" ", 3))

运行结果：

['a', 'b', 'c', 'd e']

7、upper：将字符串中的小写字母都转换为大写字母

s07 = "abc123"
print(s07.upper())

运行结果：

ABC123

8、lower：将字符串中的大写字母转换为小写字母

s08 = "ABC123"
print(s08.lower())

运行结果：

abc123

9、字符串的格式化：

9.1、使用百分号对字符串进行拼接：

• %s：接收字符串，当接收的内容为其他类型的时候，将其转化为字符串进行存储
• %d：接收数字类型
• %f：接收浮点数类型，默认保留6为小数，当需要保留两位小数时使用%.2f

print("name: %s ,age: %d" %("xiaoming", 20))

运行结果：

name: xiaoming ,age: 20

9.2、使用 format 对字符串进行拼接

print("i am {0}, age {1}, {0}".format("xiaoming", 18))
print("i am {name}, age {age}".format(name="xiaoming", age=18))

运行结果：

i am xiaoming, age 18, xiaoming

i am xiaoming, age 18

当format中的类型为字典时：

dict01 = {"name":"xiaoming", "age":18}
print("i am {name}, age {age}".format(**dict01))

运行结果：

i am xiaoming, age 18

当format中的类型为列表时：

list01 = ["xiaoming", 19]
print("i am {:s}, age {:d}".format(*list01))

运行结果：

i am xiaoming, age 19

三、列表

创建方法： list01 = [1, 2, 3]
列表中可以包含任何的数据类型
列表支持索引和切片对列表中的元素进行选取

• 举例：

list01 = [1, 2, 3, 4]
print("在列表中索引为2的元素是:", list01[2])
print("在列表中第2个元素到第4个元素分别是:", list01[1:4])

运行结果：

在列表中索引为2的元素是: 3

在列表中第2个元素到第4个元素分别是: [2, 3, 4]

列表支持 for 和 while 遍历

• 举例：

list01 = [1, 2, 3, 4]
for i in list01:
    print(i)

运行结果：

1

2

3

4

列表是由链表的方式进行存储，因此列表是一个可变的数据类型

1、修改列表的元素：

list01 = [1, 2, 3, 4, 4]
list01[4] = 5
print(list01)
list01[0:2] = [10, 20]
print(list01)

运行结果：

[1, 2, 3, 4, 5]

[10, 20, 3, 4, 5]

2、对列表的元素删除：

del list01[4]
print(list01)
del list01[0:2]
print(list01)

运行结果：

[1, 2, 3, 4]

[3, 4]

3、将字符串转换为列表：

str01 = "abcdef"
list02 = list(str01)
print(list02)

运行结果：

['a', 'b', 'c', 'd', 'e', 'f']

将其他类型转换为列表时，该类型需要能够被遍历；若该类型不能够被遍历，则不能转换为列表

4、将列表转换为字符串：

4.1、列表中包含数字和字符串：

list03 = [1, 2, "a", "b"]
s = ""
for i in list03:
    s += str(i)
print(s)

运行结果：

12ab

4.2、列表中只包含字符串：

list04 = ["a", "b", "c"]
print("".join(list04))

运行结果：

abc

4.3 列表中常用的方法：

4.3.1 append()：在列表的末尾添加元素

list01 = ["a", "b", "c", "d"]
list01.append("e")
print(list01)

运行结果：

['a', 'b', 'c', 'd', 'e']

4.3.2 extend()：扩展原列表，参数必须为可跌倒数据类型

list01 = ["a", "b", "c", "d"]
list01.extend([1, 2, 3])
print(list01)

运行结果：

['a', 'b', 'c', 'd', 1, 2, 3]

4.3.3 insert()：在指定的索引位置添加一个元素

list01 = ["a", "b", "c", "d"]
list01.insert(2, "C")
print(list01)

运行结果：

['a', 'b', 'C', 'c', 'd']

4.3.4 clear()：清空列表

list01 = ["a", "b", "c", "d"]
list01.clear()
print(list01)

运行结果：*

[]

4.3.5 pop()：将一个元素从列表中删除，并赋值给一个变量；若不加参数默认删除最后一个，参数为位置索引

list01 = ["a", "b", "c", "d"]
v = list01.pop(1)
print("现在的列表为：", list01)
print("删除的元素为：", v)

运行结果：*

现在的列表为： ['a', 'c', 'd']

删除的元素为： b

4.3.6 sorted()：对列表中的元素进行排序，默认从小到大排，原列表不会发生变化

list01 = [1, 7, 2, 6, 5, 3, 4]
print(sorted(list01))
print(list01)

运行结果：*

[1, 2, 3, 4, 5, 6, 7]

[1, 7, 2, 6, 5, 3, 4]

4.3.7 对列表进行倒序排序

list01 = [1, 7, 2, 6, 5, 3, 4]
print(sorted(list01, reverse=True))
print(list01)

运行结果：

[7, 6, 5, 4, 3, 2, 1]

[1, 7, 2, 6, 5, 3, 4]

四、元组

元组是一个不可变的列表，创建是以“()”进行标识，推荐在创建完元组的最后加上一个逗号，元组和列表一样支持索引和切片获取元素。

1、将字符串转换为元组

str01 = "abc123"
tuple01 = tuple(str01)
print(tuple01)

运行结果：

('a', 'b', 'c', '1', '2', '3')

2、将列表转换为元组

list01 = [1, 2, 3, "a", "b", "c"]
tuple01 = tuple(list01)
print(tuple01)

运行结果：

(1, 2, 3, 'a', 'b', 'c')

3、将元组转换为字符串

tuple01 = ("a", "b", "c",)
print("".join(tuple01))

abc

4、count()：获取指定元素在元组中出现的次数

tuple01 = ("a", "b", "c", "a", "b", "a",)
print(tuple01.count("a"))

运行结果：

3

5、index()：获取某一元素的索引位置

tuple01 = ("a", "b", "c", "a", "b", "a",)
print(tuple01.index("a"))

运行结果：

0

五、字典

字典是由多个键值对组成的无序的数据类型，两边有大括号进行标识，以逗号进行分割，如：

{"k1":"v1", "k2":"v2"}

键值对中的value可以是任意值；key是以哈希值进行存储，不能是列表、字典形式。

1、获取字典的value

dict01 = {"k1":2, 2:"d", 3:[1, 2]}
print(dict01["k1"])

运行结果：

2

2、删除字典的key和value

dict01 = {"k1":2, 2:"d", 3:[1, 2]}
del dict01["k1"]
print(dict01)

运行结果：

{2: 'd', 3: [1, 2]}

3、获取字典的所有key

dict02 = {"a":1, "b":2, 3:[1, 2, 3, {"a":1, "b":2}]}
for k in dict02:
    print(k)

运行结果：

a

b

3

4、获取字典的所有value

dict02 = {"a":1, "b":2, 3:[1, 2, 3, {"a":1, "b":2}]}
for v in dict02.values():
    print(v)

运行结果：

1

2

[1, 2, 3, {'a': 1, 'b': 2}]

5、获取字典的所有键值对

dict02 = {"a":1, "b":2, 3:[1, 2, 3, {"a":1, "b":2}]}
for k,v in dict02.items():
    print(k, v)

运行结果：

a 1

b 2

3 [1, 2, 3, {'a': 1, 'b': 2}]

6、get()：通过指定的key获取字典中的value，如果制定的key不存在则返回None或相应的内容

情况1：当指定的key不存在，也不指定输出的内容

d01 = {"k1": "v1", "k2": "v2", "k3": "v3"}
print(d01.get("k4"))

运行结果：

None

情况2：当指定的key不存在，也指定输出的内容

d01 = {"k1": "v1", "k2": "v2", "k3": "v3"}
print(d01.get("k4", "这个Key不存在"))

运行结果：

这个Key不存在

情况3：当指定的key存在

d01 = {"k1": "v1", "k2": "v2", "k3": "v3"}
print(d01.get("k1", "这个Key不存在"))

运行结果：

v1

7、upadte()：更新指定key的value，当这个key不存在的时候创建该key和value

情况1：当指定的key存在

d01 = {"k1": "v1", "k2": "v2", "k3": "v3"}
d01.update(k1="V1")
print(d01)

运行结果：

{'k1': 'V1', 'k2': 'v2', 'k3': 'v3'}

情况2：当指定的key不存在

d01 = {"k1": "v1", "k2": "v2", "k3": "v3"}
d01.update(k4="V1")
print(d01)

运行结果：

{'k1': 'v1', 'k2': 'v2', 'k3': 'v3', 'k4': 'V1'}

8、pop()：删除key，并将该key的value返回给一个变量，当key不存在的时候可指定返回的值

dict04 = {"k1":1, "k2":2, "k3":3}
k1 = dict04.pop("k1", "没有这个key,所以无法删除!")
print(dict04, k1)
k2 = dict04.pop("k4", "没有这个key,所以无法删除!")
print(dict04, k2)

运行结果：

{'k2': 2, 'k3': 3} 1

{'k2': 2, 'k3': 3} 没有这个key,所以无法删除!

9、keys()：获取字典中的所有key

d01 = {"k1": "v1", "k2": "v2", "k3": "v3"}
print(d01.keys())

运行结果：

dict_keys(['k1', 'k2', 'k3'])

10、values()：获取字典中的所有values

d01 = {"k1": "v1", "k2": "v2", "k3": "v3"}
print(d01.values())

运行结果：

dict_values(['v1', 'v2', 'v3'])

11、items()：获取字典中的所有键值对

d01 = {"k1": "v1", "k2": "v2", "k3": "v3"}
print(d01.items())

运行结果：

dict_items([('k1', 'v1'), ('k2', 'v2'), ('k3', 'v3')])

六、集合

集合是有不同的元素组成，集合是无序的，集合内的元素要求是不可变类型，集合是有大括号进行标识的，如：

set01 = {1, 2, 3, 4}

1、add()：在集合中添加一个元素

set01 = {1, 2, 3, 4}
set01.add(5)
print(set01)

运行结果：

{1, 2, 3, 4, 5}

2、clear()：清空集合

set01 = {1, 2, 3, 4}
set01.clear()
print(set01)

运行结果：

set()

3、copy()：对集合进行浅拷贝

set01 = {1, 2, 3, 4}
s02 = set01.copy()
print(s02)

运行结果：

{1, 2, 3, 4}

4、remove()：指定一个元素进行删除

情况1：要删除的值不存在的时候

set01 = {1, 2, 3, 4}
set01.remove(5)
print(set01)

运行结果：

set01.remove(5)

KeyError: 5

情况2：要删除的值存在的时候

set01 = {1, 2, 3, 4}
set01.remove(4)
print(set01)

运行结果：

{1, 2, 3}

5、discard()：指定一个集合中的元素进行删除，当元素不存在的时候程序不会报错

情况1：当要删除的值不存在的时候

set01 = {1, 2, 3, 4}
set01.discard("a")
print(set01)

运行结果：

{1, 2, 3, 4}

情况2：要删除的值存在的时候

set01 = {1, 2, 3, 4}
set01.discard(3)
print(set01)

运行结果：

{1, 2, 4}

6、交集：intersection()或&

set03 = {"a", "b", "c", "d"}
set04 = {"c", "d", "e", "f"}
print(set03.intersection(set04))
print(set03&set04)

运行结果：

{'d', 'c'}

{'d', 'c'}

7、并集：union()或|

set03 = {"a", "b", "c", "d"}
set04 = {"c", "d", "e", "f"}
print(set03.union(set04))
print(set03|set04)

运行结果：

{'e', 'f', 'c', 'd', 'b', 'a'}

{'e', 'f', 'c', 'd', 'b', 'a'}

8、差集：difference()或-

set03 = {"a", "b", "c", "d"}
set04 = {"c", "d", "e", "f"}
print(set03.difference(set04))
print(set03-set04)

运行结果：

{'a', 'b'}

{'a', 'b'}

9、交叉补集：symmetric_difference()或^

交叉补集是指先将两个集合内的元素合在一起，再将这两个集合相同的元素删除

set03 = {"a", "b", "c", "d"}
set04 = {"c", "d", "e", "f"}
print(set03.symmetric_difference(set04))
print(set03^set04)

运行结果：

{'f', 'e', 'a', 'b'}

{'f', 'e', 'a', 'b'}

10、isdisjoint()：当两个集合没有交集的时候返回True，有交集的时候返回False

情况1：两个集合没有交集

set05 = {1 ,2}
set06 = {3, 4}
print(set05.isdisjoint(set06))

运行结果：

True

情况2：两个集合有交集

set05 = {1, 2, 3, 4}
set06 = {3, 4}
print(set05.isdisjoint(set06))

运行结果：

False

11、issubset()或<=：当s01是s02的子集的时候返回True，反之返回False

s01 = {1,2,3}
s02 = {1,2,3,4}
print(s02<=s01)
print(s01<=s02)

运行结果：

False

True

12、issuperset()或>=：当s02是s01的父集时返回True，反之则返回False

s01 = {1,2,3}
s02 = {1,2,3,4}
print(s02.issuperset(s01))
print(s02>=s01)

运行结果：

True

True

13、update()：参数为一个可迭代的数据类型，将可迭代参数添加到集合

s01 = {1,2,3}
s01.update([4, 5, 6])
print(s01)

运行结果：

{1, 2, 3, 4, 5, 6}

14、创建一个不可变的集合：frozenset()

s03 = frozenset("123")
print(s03)

运行结果：

frozenset({'2', '3', '1'})

七、布尔值

布尔值只有False和True；数字0、空字符串、空元组、空列表以及空的字典和集合都为False。

八、type()方法

使用type()方法可以获取到所有数据的数据类型，如：

l01 = [0, 1, 2, 3]
print(type(l01))

运行结果：

<class 'list'>

九、浅拷贝和深拷贝