基本数据类型

发表于 更新于 分类于 本文字数： 12k 阅读时长 ≈ 11 分钟

1 可变与不可变类型

  • 可变类型：值改变了，id不变，证明就是在改变原值，原值是可变类型
  • 不可变类型：值改变了，id也跟着变，证明就是在产生了新的值，原值是不可变类型
1
2
3
4
5
6
7
8
9
10
11
12
x = 10
print(id(x))
x = 11
print(id(x))
#两个id不一样，所以数字是不可变类型

x = [111,222]
print(id(x))
x[0]=666666
print(id(x))
print(x)
#两次id一样，所以列表是可变类型

2 分类

2.1 int基本使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#1、用途

#2、定义方式
age = 18  # age = int(18)
print(type(age))

#2.1 数据类型转换
res=int("   18     ")
print(res,type(res))

int("aadfsadf")

int("10") + 11
"10" + 11
python一种解释型、强类型、动态类型

#3、常用操作+内置的方法
算术运算、比较运算
print(10 + 3.3)
print(10 > 3.3)

总结：int只能存一个值，是不可变类型

2.2 float基本使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
1、用途

2、定义方式
sal = 18.3  # sal = float(18.3)
print(type(sal))

2.1 数据类型转换
int("3.3")
res=float("3.3")
print(res,type(res))

3、常用操作+内置的方法
算术运算、比较运算
print(10 + 3.3)
print(10 > 3.3)

总结：只能存一个值，是不可变类型

2.3 复数（了解）

1
2
3
4
5
6
7
8
x = 1-2j
print(x.real)
print(x.imag)
print(type(x))

print(bin(11))
print(oct(11))
print(hex(11))

2.4 str基本使用

菜鸟教程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
# 1、用途：用于记录描述性质的状态

# 2、定义方式：在"",'',""" """,''' '''内包含一串字符
# msg = "18"  # msg=str("18")
# print(type(msg))

# 数据类型转换:可以把任意类型转成str类型
# res=str([1,2,3])
# print(res,type(res))

# 3、常用操作+内置的方法
#优先掌握的操作：
#1、按索引取值(正向取+反向取) ：只能取
msg = "hello world"
# print(msg[0])
# print(msg[-1])
# print(msg)
# msg[0] = "H"

#2、切片(顾头不顾尾，步长)
msg = "hello world"
print(msg[0:5])
print(msg[0:5:2])  # 0 2 4
print(msg)

print(msg[:])  # 完整拷贝字符串
print(msg[-1:-4:-1]) 
print(msg[-2::-1]) # 最后一个-1代表从索引为-2的字符,向左取值,步长为1
结果为：lrow olleh
print(msg[:-2:-1]) # 最后一个-1代表从末尾向左取值,取到索引为-2值停止,步长为1
结果为：d
print(msg[::-1])  # 将字符串倒过来

#3、长度len
msg = "h 你"
print(len(msg))

4、成员运算in和not in
msg = "hello world"
# print("wo" in msg)
print(not "wx" in msg)
print("wx" not in msg)

#5、移除空白strip
msg = "   hello    "
print(msg)
res=msg.strip()
print(res)
print(msg)

msg = "***hello******"
msg = "**+-/?*h*-ello**?-**&^**"
print(msg.strip("^&*+-/?"))

inp_user = input("username: ").strip()  # inp_user = "egon    "
inp_pwd = input("password: ").strip()
if inp_user == "egon" and inp_pwd == "123":
    print('ok')
else:
    print('no')

#6、切分split
msg = "egon:18:male"
res = msg.split(":")
print(res[0])
print(res)

res = msg.split(":",1)
print(res)

info = ["egon",18,"male"]
res1 = "%s:%s:%s" %(info[0],info[1],info[2])
res1 = ":".join(info)
print(res1)

#7、循环
msg = "egon:18:male"
for x in msg:
    print(x)

总结:存一个值,有序,不可变

可变or不可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）
字符串操作

2.4.1 字符串需要掌握的操作（****）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
1、strip,lstrip,rstrip
msg = "****hello****"
print(msg.strip("*"))
print(msg.lstrip("*"))
print(msg.rstrip("*"))

2、lower,upper
msg = "Hello"
print(msg.upper())
print(msg.lower())

3、startswith,endswith
msg = "hello world"
print(msg.startswith("he"))
print(msg.endswith("ld"))

4、format的三种玩法
print("my name is %s my age is %s" %("egon",18))

print("my name is {x} my age is {y}".format(y=18,x="egon"))
print("my name is {} my age is {}".format(18,"egon"))
print("my name is my age is {0}{0}{1}{0}".format(18,"egon"))


x=111
y=222
print(f"my name is {x} my age is {y}")

5、split,rsplit
msg="x:y:z:a:b"
print(msg.split(":",1))
print(msg.rsplit(":",1))

结果为：
['x', 'y:z:a:b']
['x:y:z:a', 'b']

6、join
print(":".join(["aaa","bbb","ccc"]))

7、replace
msg = "xx egon is hhha egon xxx egon"
print(msg.replace('egon','EGON'))
结果为：
xx EGON is hhha EGON xxx EGON

print(msg.replace('egon','EGON',1))
print(msg)

8、isdigit #判断字符串是否只包含数字
msg = "123"
print(msg.isdigit())

age = input("your age>>>: ").strip()
if age.isdigit():
    age = int(age)
    if age > 18:
        print('ok')
else:
    print('小垃圾必须输入数字')

2.4.2 需要了解的方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
1、find,rfind,index,rindex,count
msg = "hello egon xxx egon yyy egon zzz"
print(msg.find("egon",0,7))
print(msg.index("egon"))
print(msg.rfind("egon"))
print(msg.rindex("egon"))

print(msg.find("abcde"))
print(msg.index("abcde"))

print(msg.count("egon"))

2、center,ljust,rjust,zfill
print('egon'.center(50,'*'))
print('egon'.ljust(50,'*'))
print('egon'.rjust(50,'*'))
print('egon'.zfill(50))
print('egon'.rjust(50,"0"))

3、captalize,swapcase,title
msg = "hellO woRld"
print(msg.capitalize())

print(msg.swapcase())
print(msg.title())

#4、is数字系列
num1=b'4' #bytes
num2='4'  # 阿拉伯数字
num3='四' #中文数字
num4='Ⅳ' #罗马数字

1、变量值是字节串或字符串类型并且包含的阿拉伯数字，isdigit()结果才为真
print(num1.isdigit())
print(num2.isdigit())
print(num3.isdigit())
print(num4.isdigit())

2、变量值是字符串类型并且包含的阿拉伯数字，isdecimal()结果才为真
print(num2.isdecimal())
print(num3.isdecimal())
print(num4.isdecimal())

3、变量值是字符串类型并且包含的阿拉伯数字\中文数字\罗马数字，isdecimal()结果才为真
print(num2.isnumeric())
print(num3.isnumeric())
print(num4.isnumeric())

5、is其他
name='egon123'
print(name.isalnum()) #字符串由字母或数字组成
print(name.isalpha()) #字符串只由字母组成

print(name.islower())
print(name.isupper())

name="     "
print(name.isspace())

name ="Hello World"
print(name.istitle())

2.4.3 该类型总结

  • 存一个值
  • 有序
  • 不可变

2.5 list基本使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
1、用途：按位置存放多个值

2、定义方式：在[]内用逗号分割开多个任意类型的元素
l = [11,3.3,"xx",[1111,2222]]  # l = list(。。。)
print(type(l))

list数据类型转换: 所有可以被for循环遍历的类型都可以传给list然后转换成列表
print(list("abc"))
print(list({"k1":111,"k2":222}))

res=list(range(5))
print(res)

3、常用操作+内置的方法
优先掌握的操作：
1、按索引存取值(正向存取+反向存取)：即可存也可以取
list1 = [111,222,333,444,555]
print(list1[0])
print(list1[-1])

print(id(list1))
list1[0] = 666
print(id(list1))

list1[5] = 777  # 不可以用不存在的索引赋值


2、切片(顾头不顾尾，步长)
list1 = [111,222,333,444,555]
print(list1[0:3])
print(list1)

l=list1[:]  # 浅拷贝
print(l)

print(list1[::-1])

3、长度
list1 = [111,222,333,444,555]
print(len(list1))

4、成员运算in和not in
list1 = [111,222,333,444,555]
print(222 in list1)

5、追加
list1 = [111,222,333,444,555]
list1.append(666)
x = list1.append(777)
print(list1)
print(x)

list1.insert(2,666)
print(list1)

6、删除
list1 = [111,222,333,444,555]
(1) 单纯的删除-》没有返回值
del list1[0]
print(list1)

res=list1.remove(333)
print(list1)
print(res)  # None

（2）取走-》有返回值
res=list1.pop(1)  #1代表索引
print(list1)

print(res)
结果：
222

7、循环
list1 = [111,222,333,444,555]
for x in list1:
print(x)

========================需要掌握的操作
list1 = [111,222,333,333,333,444,555]
print(list1.count(333))

list1= [99,33,22,11,-3,87]
list1.reverse()
print(list1)

list1 = [111,222,333,333,333,444,555]
list1.clear()
list1.append([666,777,888])

for x in [666,777,888]:
list1.append(x)
list1.extend([666,777,888])
print(list1)

浅copy
list1.copy()
list1[:]

list1 = [111,222,777,888,999,333,333,333,444,555]
res=list1.index(333,0,3)
print(res)

list1 = [111,222,777,888,999,333,333,333,444,555]
list1.sort(reverse=True)
print(list1)

queue = []

queue.append('one')
queue.append('two')
queue.append('three')
print(queue)

print(queue.pop(0))
print(queue.pop(0))
print(queue.pop(0))

2.5.1 该类型总结

  • 存多个值
  • 有序
  • 可变

    2.6 tuple基本使用

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    1、用途：

    2、定义方式：在()内用逗号分隔开多个任意类型的元素
    x = (10,)  #  x= tuple(...)
    print(x,type(x))

    tuple数据类型转换：任意能够被for循环遍历的类型都可以交给tuple转成元组
    print(tuple("hello"))

    3、常用操作+内置的方法
    优先掌握的操作：
    1、按索引取值(正向取+反向取)：只能取
    t = (111,222,333,[44,555])
    print(t[0])
    t[0]=6666

    2、切片(顾头不顾尾，步长)
    t = (111,222,333,[44,555])
    print(t[0:3])

    3、长度
    t = (111,222,333,[44,555])
    print(len(t))

    4、成员运算in和not in
    t = (111,222,333,[44,555])
    print([44,555] in t)

    5、循环
    t = (111,222,333,[44,555])
    for x in t:
    print(x)

    需要掌握的操作：
    t = (111,222,333,[44,555])
    t.index()
    t.count()

    2.6.1 该类型总结

  • 存多个值
  • 有序
  • 不可变

    2.7 dict基本使用

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    #1、用途

    #2、定义方式：在{}内用逗号分隔开多个元素，每个元素都是key:value的格式，其中value可以是任意类型而key必须是不可变类型，通常是str类型，而且key不能重复
    dic = {111:6666,"k1":777,(1,2,3):8888,[1,2,3]:3333}   # dic = dict(...)
    dic = {111:6666,"k1":777,(1,2,3):8888,"k1":99999999}
    print(dic)
    print(dic[(1,2,3)])

    dict数据类型转换
    info = [('k1',111),('k2',222),('k3',3333)]
    dic=dict(info)
    print(dic)

    print(dict(x=1,y=2,z=3))

    3、常用操作+内置的方法
    优先掌握的操作：
    1、按key存取值：可存可取
    dic = {"name":"egon","age":18}
    dic['gender'] = "male"
    dic['name'] = "xxxx"
    print(dic)

    2、长度len
    dic = {"name":"egon","age":18}
    print(len(dic))

    3、成员运算in和not in: 以key为准
    dic = {"name":"egon","age":18}
    print('name' in dic)

    4、删除
    dic = {"name": "egon", "age": 18}
    单纯的删除
    del dic['name']
    print(dic)

    取走
    v=dic.pop("name")
    print(v)
    结果：
    egon

    v = dic.popitem()
    print(v)
    结果:
    ('age','18')

    5、键keys()，值values()，键值对items()
    dic = {"name": "egon", "age": 18}
    >>> dic.keys()
    ['age', 'name']
    >>> dic.values()
    [18, 'egon']
    >>>
    >>> dic.items()
    [('age', 18), ('name', 'egon')]
    >>>

    6、循环
    for k in dic.keys():
    print(k)

    for k in dic:
    print(k)

    for v in dic.values():
    print(v)

    for k,v in dic.items():
    print(k,v)

    8、get()
    dic = {"name": "egon", "age": 18}
    print(dic['namexxxx'])
    print(dic.get("namexxxx"))

    需要掌握的操作
    dic = {"name": "egon", "age": 18}
    dic.update({'gender':"male","age":19})
    print(dic)
    >>>
    {'name': 'egon', 'age': 19, 'gender': 'male'}

    dic = {}.fromkeys(["name","age","gender"],[])
    print(dic)
    >>> {'name': [], 'age': [], 'gender': []}

    dic['name'].append(1111)
    >>> print(dic)
    {'name': [1111], 'age': [1111], 'gender': [1111]}


    dic = {}.fromkeys(["name","age","gender"],None)
    #Python 字典 fromkeys() 函数用于创建一个新字典，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值。

    dic = {"age": 18}
    v = dic.setdefault('name',"xxx")
    v2 = dic.setdefault('age',19)
    #Python 字典 setdefault() 函数和 get()方法 类似, 如果键不存在于字典中，将会添加键并将值设为默认值。如果存在,则不作修格斯
    print(dic)
    {'age': 18, 'name': 'xxx'}
    print(v)
    xxx
    print(v2)
    19

    2.7.1 该类型总结

  • 1、可以存多个值
  • 2、是无序
  • 3、是可变类型

    2.8深浅拷贝原理

  • 浅拷贝(copy)：拷贝父对象，不会拷贝对象的内部的子对象。
  • 深拷贝(deepcopy)： copy 模块的 deepcopy 方法，完全拷贝了父对象及其子对象。

菜鸟教程

2.8.1 浅拷贝

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
l1 = [111,222,[333,444]]
l2 = l1.copy()
# l3 = l1[:]

print(id(l1[0]),id(l1[1]),id(l1[2]))
>>>4363032704 4363036256 4366729856
print(id(l2[0]),id(l2[1]),id(l2[2]))
>>>4363032704 4363036256 4366729856

l1[2][0] = 666
print(l1)
>>>[111, 222, [666, 444]]
print(l2)
>>>[111, 222, [666, 444]]

l1[0] = 777
print(l1)
>>>[777, 222, [333, 444]]
print(l2)
>>>[111, 222, [333, 444]]
"""

2.8.2 深copy

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
from copy import deepcopy

l1 = [111,222,[333,444]]
l2 = deepcopy(l1)

print(id(l1[0]),id(l1[1]),id(l1[2]))
>>> 4462676096 4462679648 4466381888
print(id(l2[0]),id(l2[1]),id(l2[2]))
>>> 4462676096 4462679648 4466382208

l1[2][0] = 666
print(l1)
>>> [111, 222, [666, 444]]
print(l2)
>>> [111, 222, [333, 444]]

l1[0] = 777
print(l1)
>>> [777, 222, [333, 444]]
print(l2)
>>> [111, 222, [333, 444]]