一、数据类型
二、整形int
三、浮点型float
四、字符串类型
五、 list列表类型
六、元组
七、字典
七集合
八可变类型与不可变类型
九数据类型总结

一、数据类型

数据类型是用来记录事物状态的，而事物的状态是不断变化的

二、整形int

2.1 用途

一般用于定义整数，例如年龄等
数字类型主要就是用来做数学运算与比较运算，因此数字类型除了与运算符结合使用之外，无需掌握的内置方法

2.2 定义方式

age = 18  # age = int(18)

2.3 常用方法

2.3.1 进制之间的转换

其他进制转十进制

# 二进制转十进制

print(int("110",2))

# 八进制转十进制

print(int("123",8))

# 十六进制转

print(int("321",16))

十进制转其他进制

# 十进制转二进制：

print(bin(108))  # 0b 1101100

# 十进制转八进制：

print(oct(83))   # 0o 123

# 十进制转十六进制：

print(hex(1000))  # 0x 3e8

2.3.2 数据类型转换

int可以将由纯整数构成的字符串直接转成整形，若包含其他任意非整数符号，则会报错

s = '123'

res = int(s)

# 若想转换带有小数点的数字，需要先转成float类型，再次转为int类型，不可以直接转换。

s = '12.0'

res_float = float(s)

int_float = int(res_float)

3 类型总结

值变id不变就是可变类型

值变id也变就是不可变类型

有索引的类型都是有序的

因此，整形：

不可变类型
无序
存在一个值

三、浮点型float

3.1 用途

用于记录小数，身高，体重，薪资

3.2 定义方式

height = 180.0  # height = float(180.0)

3.3 常用方法

数学计算
数字类型转换

3.4 数字类型转换

字符串 ---> float ---> int

s1 = '1.0'

f1 = float(s1)

print(f1)

print(type(f1))

a1 = int(f1)

print(a1)

3.5 类型总结

值变id不变是可变类型

值变id也变是不可变类型

有索引的类型都是有序的

因此，浮点型：

不可变类型
无序
存在一个值

四、字符串类型

3.1 用途

用于存储一些描述性信息，如名字

3.2 定义方式

name = '高弟'

# 补充：字符串前面加一个小写的r，代表转义

3.3 优先掌握的知识点

3.3.1索引取值

索引取值（正向取、反向取），只能取不能存

s1 = 'hello world'

# 按照索引取值，取hello中的o

print(s1[4])  # 正向取

print(s1[-7])  # 反向取

3.3.2 索引切片

截取字符串中的一小段字符串

# 取world

print(s1[6:11])

print(s1[6:])

# 取hello

print(s1[:6])

print(s1[0:-2:2]) # 从0开始取值，每隔2个取一个，到索引为-2结束

3.3.3 成员运算：

in
not in

# 判断o是否在s1中

print('o' in s1)

print('o' not in s1)

# 返回结果是bool值

True

False

3.3.4 .strip()

默认去除字符首尾的空格，还可以传入参数指定去除字符

input无论接受的是什么类型，一定返回的是字符串

a1 = '    sean   '

print(len(a1))

print(a1.strip())

print(len(a1.strip()))

11

sean

4

3.3.5 split

切分，对字符串进行切分，可以指定切分的分隔符，返回是一个列表

a1 = '8215\宿舍\逝去的记忆'

print(a1.split('\\'))

['8215', '宿舍', '逝去的记忆']

# 在python中单斜杠有特殊意义

# python中\\双斜杠代表\自己本身

3.3.6 len()

获取当前数据中的元素的个数

s1 = '你好啊世界'

print(len(s1))

5

3.4 优先掌握的知识点

3.4.1 strip，rstrip, lstrip

# rstrip 去掉右边的字符

a1 = '******sean*******'

print(len(a1))

print(a1.rstrip('*'))

print(len(a1.rstrip('*')))

******sean

# lstrip 去掉左边的字符

3.4.2 lower\upper

lower 全部变成小写
upper 全部变成大写

s1 = 'Hello world'

print(s1.upper())

print(s1.lower())

HELLO WORLD

hello world

3.4.3 startswith\endswith

判断当前字符串是否以XXX开头，或者以XXX结尾，返回的一定是布尔值。

a1 = 'hello python'

print(a1.startswith('h'))

print(a1.endswith('o'))

True

False

3.4.4 .format()

格式化字符串

name = 'sean'

age = '18'

print('my name is {names}, my age is {ages}'.format(names=name, ages=age))

my name is sean, my age is 18

# print("你的名字是：{name}，你的年龄是：{age},{gender}".format(age=age,name=name,gender='male'))

# 通过大括号接收变量，在字符串前面一定要加一个小写f，，，，在python3.6以后才有

# print(f"你的名字是：{name}，你的年龄是：{age}")

3.4.4 split\rsplit

l1 = '我的，杯子，是透明的'

print(l1.split('，', 1))  # 可以指定切分次数

print(l1.rsplit('，', 1))  # 从右边开始切分

3.4.5 join

将传入的（列表）中每一个字符，依次取出，以指定的分隔符进行拼接(传入的列表内只能是字符串)

l1 = ['我的', '杯子', '是透明的']

print('-'.join(l1))

我的-杯子-是透明的

3.4.6 replace

将字符串中的某一段文字进行替换，参数，先老值，再新值

s1 = 'you are my sunshine'

print(s1.replace('sunshine', 'eye'))

you are my eye

3.4.7 .isdigit()

判断当前字符串中是否为整数，bytes、unicode，返回布尔值

score = input('please enter your score：')

if score.isdigit():

    score = int(score)

    if score >= 90:

        print('优秀')

else:

    print('输入有误')

3.5 字符串了解的知识点

3.5.1 find

查找当前字符串中某个元素的位置，返回索引，找不到返回-1

s1 = '你今天吃饭吃了吗？'

print(s1.find("？",))

3.5.2 index

查找当前字符串中某个元素的位置，返回索引，找不到返回异常

print(s1.index("？"))

3.5.3 count

统计当前字符串中某一个元素的个数

print(s1.count("吃"))

3.5.4 center\ljust\rjust\zfill

print("欢迎光临".center(8,"-"))

print("欢迎光临".ljust(30,"-"))

print("欢迎光临".rjust(30,"-"))

print("欢迎光临".zfill(50))

3.6 类型总结

有序
不可变类型
存一个值

五、 list列表类型

5.1 用途

用于存一个或者多个不同类型的值

5.2 定义方式

通过中括号存值，每个值之间通过逗号进行分隔

5.3 优先掌握的知识点

5.3.1 索引取值

l1 = [1, 2, 3, 4,5]

print(l1[2])

l1[2] = 222

print(l1)

5.3.2 索引切片

print(l1[1:4])

5.3.3 append()

在列表尾部追加单个字符

l1 = [1, 2, 3, 4, 5]

l1.append(10000)

print(l1)

l1.append([9,0])

print(l1)

[1, 2, 3, 4, 5, 10000]

[1, 2, 3, 4, 5, 10000, [9, 0]]

5.3.4 insert()

指定索引在列表中插入单个元素

l1 = [1, 2, 3, 4, 5]

l1.insert(3,999)

print(l1)

[1, 2, 3, 999, 4, 5]

5.3.5 extend()

从尾部一次性插入多个值

l1 = [1, 2, 3, 4, 5]

l1.extend([0, 6, 7, 8])

print(l1)

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

5.3.6 remove()

指定值删除，比较彻底

l1.remove(1)

print(l1)

5.3.7 pop()

不传值，默认从最后开始删，指定索引删值,pop是有返回值的

l1 = [1, 2, 3, 4,5]

val = l1.pop(2)

print(l1)

print(val)

# 不传值默认从最后面删除

l1.pop()

print(l1)

l1.pop()

print(l1)

l1.pop()

print(l1)

5.3.8 del

万能删除，指定索引

#del l3[0]

5.3.9 .reverse()

反转

l = [11,22,33,44]

l.reverse()

l

[44,33,22,11]

>>> l = [11,22,3,42,7,55]

>>> l.sort()

>>> l

[3, 7, 11, 22, 42, 55]  # 默认从小到大排序

>>> l = [11,22,3,42,7,55]

>>> l.sort(reverse=True)  # reverse用来指定是否跌倒排序，默认为False

>>> l

[55, 42, 22, 11, 7, 3]

5.3.10 .sort()给列表内所有元素排序

排序，在原列表上进行排序操作

排序时列表元素之间必须是相同数据类型，不可混搭，否则报错

列表级的排序

l2 = [3, 2, 2, 4, 1, 5, 6]

l2.sort()

print(l2)

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

Process finished with exit code 0

l2 = [3, 2, 2, 4, 1, 5, 6]

l2.sort(reverse=True)  # reverse=True用来指定排序为倒序，默认为False

print(l2)r

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

Process finished with exit code 0

python的内置函数，在排序时生成了一个新列表，原数据不变

l2 = [3, 2, 2, 4, 1, 5, 6]

l3 = sorted(l2,)

print(l3)

5.3.11 .count()

统计当前列表内指定元素的个数

l1 = ['sean', 'egon', 'tank', 'sean']

# count:统计当前列表内指定元素的个数

print(l1.count('sean'))

2

5.3.12 .index()

获取当前指定元素的索引值，还可以指定指定查找范围

l1 = ['sean', 'egon', 'tank', 'sean']

print(l1.index('sean', 1, 4))

5.3.13 clear()

清空列表数据

l2 = [3, 2, 2, 4, 1, 5, 6]

print(l2)

l2.clear()

print(l2)

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

[]

Process finished with exit code 0

5.4 队列和堆栈

5.4.1 队列

先进先出（先吃后拉）

5.4.2 堆栈

先进后出（先吃后涂）

5.5 类型总结

有序
可变
存在多个值

六、元组

6.1 用途

元组与列表类似，也是可以存多个任意类型的元素，不同之处在于元组的元素不能修改，即元组相当于不可变的列表，用于记录多个固定不允许修改的值，单纯用于取

6.2 定义方式

用过小括号存储数据，数据与数据之间通过逗号分隔,(值不能被改变)

定义容器类型的时候，如果里面只有一个值，在值的后面加上一个逗号
在元组中如果不加，就是字符串

# 在()内用逗号分隔开多个任意类型的值

>>> countries = ("中国"，"美国"，"英国")  # 本质:countries = tuple("中国"，"美国"，"英国")

# 强调：如果元组内只有一个值，则必须加一个逗号，否则()就只是包含的意思而非定义元组

>>> countries = ("中国"，)  # 本质:countries = tuple("中国")

6.3 类型转换

# 但凡能被for循环的遍历的数据类型都可以传给tuple()转换成元组类型

t1 = tuple([1, 2, 3, 4, 5])  # 列表转为元组

print(t1)

print(type(t1))

(1, 2, 3, 4, 5)

<class 'tuple'>

t1 = tuple('你好啊世界！')  # 字符串转元组

print(t1)

print(type(t1))

('你', '好', '啊', '世', '界', '！')

<class 'tuple'>

# tuple()会跟for循环一样遍历出数据类型中包含的每一个元素然后放到元组中

6.4 使用

6.4.1 按索引取值

>>> tuple1 = (1, 'hhaha', 15000.00, 11, 22, 33)

# 1、按索引取值(正向取+反向取)：只能取，不能改否则报错！

>>> tuple1[0]

1

>>> tuple1[-2]

22

>>> tuple1[0] = 'hehe'  # 报错：TypeError:

6.4.2 切片(顾头不顾尾，步长)

# 2、切片(顾头不顾尾，步长)

>>> tuple1[0:6:2]

(1, 15000.0, 22)

6.4.3 len() 长度

# 3、长度

>>> len(tuple1)

6

6.4.4 成员运算 in 和 not in

# 4、成员运算 in 和 not in

>>> 'hhaha' in tuple1

True

>>> 'hhaha' not in tuple1

False

6.4.5 循环 for 取值

# 5、循环

>>> for line in tuple1:

...     print(line)

1

hhaha

15000.0

11

22

33

七、字典

7.1 定义方式

通过大括号来存储数据，通过key: value的关系映射键值对，每个键值对中间通过逗号分隔

key:一定是一个不可变类型
value：可以是任意类型

# 定义：在{}内用逗号分隔开多元素，每一个元素都是key:value的形式，其中value可以是任意类型，而key则必须是不可变类型，通常key应该是str类型，因为str类型会对value有描述性的功能

info={'name':'tony','age':18,'sex':'male'} #本质info=dict({....})

# 也可以这么定义字典

info=dict(name='tony',age=18,sex='male') # info={'age': 18, 'sex': 'male', 'name': 'tony'}

# zip的定义方式：了解即可

l1 = ['name',"age"]

l2 = ['egon',18]

z1 = zip(l1,l2)

print(dict(z1))

7.2 类型转换

# 转换1:

>>> info=dict([['name','tony'],('age',18)])

>>> info

{'age': 18, 'name': 'tony'}

# 转换2：fromkeys会从元组中取出每个值当做key，然后与None组成key:value放到字典中

>>> {}.fromkeys(('name','age','sex'),None)

{'age': None, 'sex': None, 'name': None}

7.3 使用

7.3.1 优先掌握的操作

7.3.1.1 按key存取值：可存可取

# 1、按key存取值：可存可取

# 1.1 取

>>> dic = {

...     'name': 'xxx',

...     'age': 18,

...     'hobbies': ['play game', 'basketball']

... }

>>> dic['name']

'xxx'

>>> dic['hobbies'][1]

'basketball'

# 1.2 对于赋值操作，如果key原先不存在于字典，则会新增key:value

>>> dic['gender'] = 'male'

>>> dic

{'name': 'tony', 'age': 18, 'hobbies': ['play game', 'basketball'],'gender':'male'}

# 1.3 对于赋值操作，如果key原先存在于字典，则会修改对应value的值

>>> dic['name'] = 'tony'

>>> dic

{'name': 'tony', 'age': 18, 'hobbies': ['play game', 'basketball']}

7.3.1.2 长度len()

# 2、长度len

>>> len(dic)

3

7.3.1.3 成员运算in和not in

# 3、成员运算in和not in

>>> 'name' in dic  # 判断某个值是否是字典的key

True

7.3.1.4 删除 pop

# 4、删除

>>> dic.pop('name')  # 通过指定字典的key来删除字典的键值对

>>> dic

{'age': 18, 'hobbies': ['play game', 'basketball']}

7.3.1.5 键keys()，值values()，键值对items()

# 5、键keys()，值values()，键值对items()

>>> dic = {'age': 18, 'hobbies': ['play game', 'basketball'], 'name': 'xxx'}

# 获取字典所有的key

>>> dic.keys()

dict_keys(['name', 'age', 'hobbies'])

# 获取字典所有的value

>>> dic.values()

dict_values(['xxx', 18, ['play game', 'basketball']])

# 获取字典所有的键值对

>>> dic.items()

dict_items([('name', 'xxx'), ('age', 18), ('hobbies', ['play game', 'basketball'])])

7.3.1.6 循环for取值

# 6、循环

# 6.1 默认遍历的是字典的key

>>> for key in dic:

...     print(key)

...

age

hobbies

name

# 6.2 返回所有的键，以列表的形式

>>> for key in dic.keys():

...     print(key)

...

age

hobbies

name

# 6.3 返回所有的值

>>> for key in dic.values():

...     print(key)

...

18

['play game', 'basketball']

xxx

# 6.4 返回所有的键值对

>>> for key in dic.items():

...     print(key)

...

('age', 18)

('hobbies', ['play game', 'basketball'])

('name', 'xxx')

6.3.2 需要掌握的操作

1.get()

>>> dic= {'k1':'jason','k2':'Tony','k3':'JY'}

>>> dic.get('k1')

'jason'  # key存在，则获取key对应的value值

>>> res=dic.get('xxx') # key不存在，不会报错而是默认返回None

>>> print(res)

None

>>> res=dic.get('xxx',666) # key不存在时，可以设置默认返回的值

>>> print(res)

666

# ps:字典取值建议使用get方法

2.pop()

>>> dic= {'k1':'jason','k2':'Tony','k3':'JY'}

>>> v = dic.pop('k2')  # 删除指定的key对应的键值对,并返回值

>>> dic

{'k1': 'jason', 'kk2': 'JY'}

>>> v

'Tony'

3.popitem()

>>> dic= {'k1':'jason','k2':'Tony','k3':'JY'}

>>> item = dic.popitem()  # 随机删除一组键值对,并将删除的键值放到元组内返回

>>> dic

{'k3': 'JY', 'k2': 'Tony'}

>>> item

('k1', 'jason')

4.update()

# 用新字典更新旧字典，有则修改，无则添加

>>> dic= {'k1':'jason','k2':'Tony','k3':'JY'}

>>> dic.update({'k1':'JN','k4':'xxx'})

>>> dic

{'k1': 'JN', 'k3': 'JY', 'k2': 'Tony', 'k4': 'xxx'}

5.fromkeys()

将逗号后面的值依次传入到前面的key中并组成字典

>>> dic = dict.fromkeys(['k1','k2','k3'],[])

>>> dic

{'k1': [], 'k2': [], 'k3': []}

6.setdefault()

如果传入的值已存在于字典，返回原来的value

如果传入的值不存在于字典，新增一条数据，返回更新之后的value

# key不存在则新增键值对，并将新增的value返回

>>> dic={'k1':111,'k2':222}

>>> res=dic.setdefault('k3',333)

>>> res

333

>>> dic # 字典中新增了键值对

{'k1': 111, 'k3': 333, 'k2': 222}

# key存在则不做任何修改，并返回已存在key对应的value值

>>> dic={'k1':111,'k2':222}

>>> res=dic.setdefault('k1',666)

>>> res

111

>>> dic # 字典不变

{'k1': 111, 'k2': 222}

七集合

7.1 作用

集合、list、tuple、dict一样都可以存放多个值，但是集合主要用于：去重、关系运算

7.2 定义

"""

定义：在{}内用逗号分隔开多个元素，集合具备以下三个特点：

     1：每个元素必须是不可变类型

     2：集合内没有重复的元素

     3：集合内元素无序

"""

s = {1,2,3,4}  # 本质 s = set({1,2,3,4})

# 注意1：列表类型是索引对应值，字典是key对应值，均可以取得单个指定的值，而集合类型既没有索引也没有key与值对应，所以无法取得单个的值，而且对于集合来说，主要用于去重与关系元素，根本没有取出单个指定值这种需求。

# 注意2:{}既可以用于定义dict，也可以用于定义集合，但是字典内的元素必须是key:value的格式，现在我们想定义一个空字典和空集合，该如何准确去定义两者?

d = {} # 默认是空字典

s = set() # 这才是定义空集合

7.3 类型转换

# 但凡能被for循环的遍历的数据类型（强调：遍历出的每一个值都必须为不可变类型）都可以传给set()转换成集合类型

>>> s = set([1,2,3,4])

>>> s1 = set((1,2,3,4))

>>> s2 = set({'name':'jason',})

>>> s3 = set('egon')

>>> s,s1,s2,s3

{1, 2, 3, 4} {1, 2, 3, 4} {'name'} {'e', 'o', 'g', 'n'}

7.4 使用

7.4.1 关系运算

我们定义两个集合friends与friends2来分别存放两个人的好友名字，然后以这两个集合为例讲解集合的关系运算

>>> friends1 = {"zero","kevin","jason","egon"} # 用户1的好友们

>>> friends2 = {"Jy","ricky","jason","egon"}   # 用户2的好友们

两个集合的关系如下图所示

# 1.合集(|)：求两个用户所有的好友（重复好友只留一个）

>>> friends1 | friends2

{'kevin', 'ricky', 'zero', 'jason', 'Jy', 'egon'}

# 2.交集(&)：求两个用户的共同好友

>>> friends1 & friends2

{'jason', 'egon'}

# 3.差集(-)：

>>> friends1 - friends2 # 求用户1独有的好友

{'kevin', 'zero'}

>>> friends2 - friends1 # 求用户2独有的好友

{'ricky', 'Jy'}

# 4.对称差集(^) # 求两个用户独有的好友们（即去掉共有的好友）

>>> friends1 ^ friends2

{'kevin', 'zero', 'ricky', 'Jy'}

# 5.值是否相等(==)

>>> friends1 == friends2

False

# 6.父集：一个集合是否包含另外一个集合

# 6.1 包含则返回True

>>> {1,2,3} > {1,2}

True

>>> {1,2,3} >= {1,2}

True

# 6.2 不存在包含关系，则返回True

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

False

>>> {1,2,3} >= {1,3,4,5}

False

# 7.子集

>>> {1,2} < {1,2,3}

True

>>> {1,2} <= {1,2,3}

True

7.4.2 去重

集合去重复有局限性

# 1. 只能针对不可变类型

# 2. 集合本身是无序的，去重之后无法保留原来的顺序

示例如下

>>> l=['a','b',1,'a','a']

>>> s=set(l)

>>> s # 将列表转成了集合

{'b', 'a', 1}

>>> l_new=list(s) # 再将集合转回列表

>>> l_new

['b', 'a', 1] # 去除了重复，但是打乱了顺序

# 针对不可变类型，并且保证顺序则需要我们自己写代码实现，例如

l=[

    {'name':'lili','age':18,'sex':'male'},

    {'name':'jack','age':73,'sex':'male'},

    {'name':'tom','age':20,'sex':'female'},

    {'name':'lili','age':18,'sex':'male'},

    {'name':'lili','age':18,'sex':'male'},

]

new_l=[]

for dic in l:

    if dic not in new_l:

        new_l.append(dic)

print(new_l)

# 结果：既去除了重复，又保证了顺序，而且是针对不可变类型的去重

[

    {'age': 18, 'sex': 'male', 'name': 'lili'},

    {'age': 73, 'sex': 'male', 'name': 'jack'},

    {'age': 20, 'sex': 'female', 'name': 'tom'}

]

7.4.3 其他操作

# 1.长度

>>> s={'a','b','c'}

>>> len(s)

3

# 2.成员运算

>>> 'c' in s

True

# 3.循环

>>> for item in s:

...     print(item)

...

c

a

b

7.5 练习

"""

一.关系运算

　　有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合

　　pythons={'jason','egon','kevin','ricky','gangdan','biubiu'}

　　linuxs={'kermit','tony','gangdan'}

　　1. 求出即报名python又报名linux课程的学员名字集合

　　2. 求出所有报名的学生名字集合

　　3. 求出只报名python课程的学员名字

　　4. 求出没有同时这两门课程的学员名字集合

"""

# 求出即报名python又报名linux课程的学员名字集合

>>> pythons & linuxs

# 求出所有报名的学生名字集合

>>> pythons | linuxs

# 求出只报名python课程的学员名字

>>> pythons - linuxs

# 求出没有同时这两门课程的学员名字集合

>>> pythons ^ linuxs

八可变类型与不可变类型

可变数据类型：值发生改变时，内存地址不变，即id不变，证明在改变原值

不可变类型：值发生改变时，内存地址也发生改变，即id也变，证明是没有在改变原值，是产生了新的值

数字类型:

>>> x = 10

>>> id(x)

1830448896

>>> x = 20

>>> id(x)

1830448928

# 内存地址改变了，说明整型是不可变数据类型，浮点型也一样

字符串

>>> x = "Jy"

>>> id(x)

938809263920

>>> x = "Ricky"

>>> id(x)

938809264088

# 内存地址改变了，说明字符串是不可变数据类型

列表

>>> list1 = ['tom','jack','egon']

>>> id(list1)

486316639176

>>> list1[2] = 'kevin'

>>> id(list1)

486316639176

>>> list1.append('lili')

>>> id(list1)

486316639176

# 对列表的值进行操作时，值改变但内存地址不变，所以列表是可变数据类型

元组

>>> t1 = ("tom","jack",[1,2])

>>> t1[0]='TOM' # 报错：TypeError

>>> t1.append('lili') # 报错：TypeError

# 元组内的元素无法修改，指的是元组内索引指向的内存地址不能被修改

>>> t1 = ("tom","jack",[1,2])

>>> id(t1[0]),id(t1[1]),id(t1[2])

(4327403152, 4327403072, 4327422472)

>>> t1[2][0]=111 # 如果元组中存在可变类型，是可以修改，但是修改后的内存地址不变

>>> t1

('tom', 'jack', [111, 2])

>>> id(t1[0]),id(t1[1]),id(t1[2]) # 查看id仍然不变

(4327403152, 4327403072, 4327422472)

字典

>>> dic = {'name':'egon','sex':'male','age':18}

>>>

>>> id(dic)

4327423112

>>> dic['age']=19

>>> dic

{'age': 19, 'sex': 'male', 'name': 'egon'}

>>> id(dic)

4327423112

# 对字典进行操作时，值改变的情况下，字典的id也是不变，即字典也是可变数据类型

九数据类型总结

python入门之数据类型及内置方法的更多相关文章

python学习day7 数据类型及内置方法补充
http://www.cnblogs.com/linhaifeng/articles/7133357.html#_label4 1.列表类型用途:记录多个值(一般存放同属性的值) 定义方法在[]内 ...
08python语法入门--基本数据类型及内置方法
数字类型int与float 定义类型转换使用字符串定义类型转换使用优先掌握的操作需要掌握的操作了解操作列表定义类型转化使用优先掌握的操作需要掌握的操作了解操作元组作 ...
python 入门基础4 --数据类型及内置方法
今日目录: 零.解压赋值+for循环一. 可变/不可变和有序/无序二.基本数据类型及内置方法 1.整型 int 2.浮点型float 3.字符串类型 4.列表类型三.后期补充内容零.解压赋值+ ...
day6 基本数据类型及内置方法
day6 基本数据类型及内置方法一.10进制转其他进制 1. 十进制转二进制 print(bin(11)) #0b1011 2. 十进制转八进制 print(hex(11)) #0o13 3. 十进 ...
while + else 使用，while死循环与while的嵌套，for循环基本使用，range关键字，for的循环补充(break、continue、else) ，for循环的嵌套，基本数据类型及内置方法
今日内容内容概要 while + else 使用 while死循环与while的嵌套 for循环基本使用 range关键字 for的循环补充(break.continue.else) for循环的嵌 ...
Day 07 数据类型的内置方法[列表,元组,字典,集合]
数据类型的内置方法一:列表类型[list] 1.用途:多个爱好,多个名字,多个装备等等 2.定义:[]内以逗号分隔多个元素,可以是任意类型的值 3.存在一个值/多个值:多个值 4.有序or无序:有序 ...
if循环&数据类型的内置方法（上）
目录 if循环&数据类型的内置方法 for循环 range关键字 for+break for+continue for+else for循环的嵌套使用数据类型的内置方法 if循环&数 ...
wlile、 for循环和基本数据类型及内置方法
while + else 1.while与else连用当while没有被关键字break主动结束的情况下正常结束循环体代码之后执行else的子代码 """ while ...
while和for循环的补充与数据类型的内置方法(int, float, str)
目录 while与for循环的补充 while + else 死循环 while的嵌套 for补充 range函数 break与continue与else for循环的嵌套数据类型的内置方法 int ...

随机推荐

记一次CSS反爬
目标网址:猫眼电影主要流程爬取每一个电影所对应的url 爬取具体电影所对应的源码解析源码,并下载所对应的字体使用 fontTools 绘制所对应的数字运用机器学习的方法识别对应的数字在源码 ...
JS--插件：树Tree 开发与实现
日常在Web项目开发时,经常会碰到树形架构数据的显示,从数据库中获取数据,并且显示成树形.为了方便,我们可以写一个javascript的一个跨浏览器树控件,后续可以重复使用.本节分享一个自己开发的JS ...
TinyMCE常用插件
Advanced Tables 基于table插件的增强表格插件,添加了排序功能. tinymce.init({ plugins: 'table advtable', menubar: 'table' ...
英语cabardine麝香cabardine单词
麝香(cabardine)是麝科动物林麝Moschus berezovskii Flerov. 马麝M. sifanicusPrzewalski或原麝M.moschiferus L.雄体香囊中的干燥分 ...
kubernetes集群内通过endpoint访问外部服务
kubernetes内的服务访问集群外独立的服务最好通过endpoint方式,例如MySQL 1.创建mysql-service.yaml apiVersion: v1 kind: Service m ...
Mysql 主从报错：1141
主从同步,从库报错代码:1141 ,错误信息如下: Master_Port: 3306 Connect_Retry: 60 Master_Log_File: binlog.000086 Read_Ma ...
mysql foreignkey
1.foreign key 当数据足够大的时候,字段会出现大量重复, 解决:额外定义一个大量冗余的字段表,(有id) 一张是关联表(从表),一张是被关联表(主表) 进行关联的时候 ,先创建被关联表, ...
nodejs，npm 安装配置步骤
http://xiaoyaojones.blog.163.com/blog/static/28370125201351501113581/ 参照上述网址中的方法特别强调一下,在第三步的时候,在命令行 ...
Python面试题(1)
1.如何反向迭代一个序列 #如果是一个list,最快的方法使用reversetempList = [1,2,3,4]tempList.reverse()for x in tempList: pr ...
Windows中的txt文件到Mac打开是乱码解决办法
在Mac下打开“文本编辑”程序之后,选择菜单“文本编辑” -> “偏好设置”.2)在“偏好设置”中选择第二个标签页“打开和存储”,选择“纯文本文件编码”中的“打开文件”和“存储文件”修改成为“中 ...

python入门之数据类型及内置方法

一、数据类型

二、整形int

2.1 用途

2.2 定义方式

2.3 常用方法

2.3.1 进制之间的转换

2.3.2 数据类型转换

3 类型总结

三、浮点型float

3.1 用途

3.2 定义方式

3.3 常用方法

3.4 数字类型转换

3.5 类型总结

四、字符串类型

3.1 用途

3.2 定义方式

3.3 优先掌握的知识点

3.3.1索引取值

3.3.2 索引切片

3.3.3 成员运算：

3.3.4 .strip()

3.3.5 split

3.3.6 len()

3.4 优先掌握的知识点

3.4.1 strip，rstrip, lstrip

3.4.2 lower\upper

3.4.3 startswith\endswith

3.4.4 .format()

3.4.4 split\rsplit

3.4.5 join

3.4.6 replace

3.4.7 .isdigit()

3.5 字符串了解的知识点

3.5.1 find

3.5.2 index

3.5.3 count

3.5.4 center\ljust\rjust\zfill

3.6 类型总结

五、 list列表类型

5.1 用途

5.2 定义方式

5.3 优先掌握的知识点

5.3.1 索引取值

5.3.2 索引切片

5.3.3 append()

5.3.4 insert()

5.3.5 extend()

5.3.6 remove()

5.3.7 pop()

5.3.8 del

5.3.9 .reverse()

5.3.10 .sort()给列表内所有元素排序

5.3.11 .count()

5.3.12 .index()

5.3.13 clear()

5.4 队列和堆栈

5.4.1 队列

5.4.2 堆栈

5.5 类型总结

六、 元组

6.1 用途

6.2 定义方式

6.3 类型转换

6.4 使用

6.4.1 按索引取值

6.4.2 切片(顾头不顾尾，步长)

6.4.3 len() 长度

6.4.4 成员运算 in 和 not in

6.4.5 循环 for 取值

七、 字典

7.1 定义方式

7.2 类型转换

7.3 使用

7.3.1 优先掌握的操作

7.3.1.1 按key存取值：可存可取

7.3.1.2 长度len()

7.3.1.3 成员运算in和not in

7.3.1.4 删除 pop

六、元组

七、字典

七集合

八可变类型与不可变类型

九数据类型总结