内容概要

八大基本数据类型
- 数字类型
  - 整数(int)
  - 浮点数(float)
- 字符串类型(str)
- 列表类型(list)
- 字典类型(dict)
  - dictionary
- 布尔类型(bool)
- 元组类型(tuple)
- 集合类型(set)

今日详细内容

【一】数字类型

【1】整形、浮点型（int/float）

整数类型(int)用于表示整数，是一种基本的数字类型，广泛用于表示计数、索引等整数值。
浮点类型(float)用于表示带有小数部分的数值，适用于需要更精确表示的情况。

# 【1】整形
number = 1
# 查看内存地址
print(id(number)) #140710426039968
# 查看变量类型
print(type(number)) #<class 'int'>
#查看变量值
print(number) #1

# 【2】浮点型---float
number_float = 3.1415
print(number_float) #3.1415
print(type(number_float)) #<class 'float'>

【二】字符串类型

字符串可以使用单引号、双引号或三引号进行定义

用单引号、双引号、多引号，都可以定义字符串
本质上是没有区别的(这些引号定义字符串的方式是等价的)

# [1] 字符串类型 --str
name = 'dhy'
print(name)  #dhy
print(type(name)) #<class 'str'>


# [2] 定义方式
#  字符串可以使用单引号、双引号或三引号进行定义
word = ''''hello world'''
print(word) #'hello world
print(type(word)) #<class 'str'>


word_sentence = "i'm dhy" #双引号当中可用多个单引号,但单引号当中不支持单个单引号

#[3]字符串相加相乘
name1 = 'dhy'
name2 = 'qjm'
print(name1+name2) #dhyqjm
print(name1*name2) #字符串不能相乘,可乘数字
print(name1*3) #dhydhydhy

（4）索引取值

字符串属于序列类型，所谓序列，指的是一块可存放多个值的连续内存空间，这些值按一定顺序排列，可通过每个值所在位置的编号（称为索引）访问它们。

msg = 'hello world'
print(len(msg)) #11
print(msg[0]) #h
print(msg[10]) #d

[5]格式化语法输出

print('my name is dhy!')
 # 一:占位符 %
name = 'dhy'
age = 18
print('my name is %s'%name)
print('my age is %d'%age)

# 二: f{}  里面可放表达式也可以放变量名
name = 'dhy'
print(f'my name is {name}')
print(f'my name is {1+1}')

# 三: format
name = 'dhy'
print('my name is {}'.format(name))

【三】列表类型

用来存取多个相同属性的值，并且方便存取

name_list = ['dhy','qjm','qcc']

print(name_list) #['dhy', 'qjm', 'qcc']
print(type(name_list)) #<class 'list'>

#索引取值
print(name_list[0]) #dhy

#列表可以嵌套在其他列表中，形成二维或多维数组，通过嵌套的方式可以方便地处理复杂的数据结构

# 列表嵌套
class1 = ['张三', '李四', '王五']
class2 = ['Tom', 'Jerry', 'Spike']
classes = [class1, class2]#[['张三', '李四', '王五'], ['Tom', 'Jerry', 'Spike']]
print(classes)

# 嵌套取值
student_1_class_1 = classes[0][0]
print(student_1_class_1)  # 张三
student_2_class_2 = classes[1][1]
print(student_2_class_2)  # Jerry

【四】字典类型

（1）取值

[1]按[key]

dict_dhy = {'name': 'dhy', 'age': 18, 'height': '180'}
print(dict_dhy['name'])  # dhy

[2]get取值

使用get方法可以根据键获取对应的值，如果键不存在，则返回指定的值

dict_dhy = {'name': 'heart', 'age': 18}
print(dict_dhy.get('name'))  # dhy
print(dict_dhy.get('height', 180))  # 180

（2）计算长度 len

使用len函数可以计算字典中键值对的个数

dict_dhy = {'name': 'dhy', 'age': 18, 'height': 180}
print(len(dict_one))  # 3

（3）成员运算

使用in和not in可以判断键是否存在字典中

dict_dhy = {'name': 'dhy', 'age': 18, 'height': 180}
print('name' in dict_one)  # True

（4）增加

如果没有这个键，那就将键添加进字典里
如果存在这个键，就直接替换成新内容

dict_one = {'name': 'dhy', 'age': 18, 'height': 180}
dict_one['sex'] = '男'
dict_one['name'] = 'dhy1'
print(dict_one)  # {'name': 'dhy1', 'age': 18, 'height': 180, 'sex': '男'}

[1] update(key=value)

使用update()方法可以批量增加键值对，如果键已经存在，则更新字典

dict_one = {'name': 'heart'}
dict_one.update(sex='男', hobby=['music'])
print(dict_one)  # {'name': 'heart', 'sex': '男', 'hobby': ['music']}

[2]setdefault(key,value)

用于获取指定键的值，如果键不存在，则返回默认值，有返回值，并且返回值就是你添加到字典中的值，只能单个增加元素

dict_one = {'name': 'dhy'}
res = dict_one.setdefault('sex', '男')
print(dict_one)  # {'name': 'dhy', 'sex': '男'}
print(res)  # 男

（5）删除

[1]del

根据字典中的键删除指定的键值

dict_one = {'name': 'dhy', 'age': 18}
del dict_one['name']
print(dict_one)  # {'age': 18}

[2]pop()

使用pop方法可以根据键弹出字典中的键值对，同时返回被弹出的值

dict_one = {'name': 'dhy', 'age': 18, 'height': 180}
print(dict_one.pop('age'))  # 18
print(dict_one)  # {'name': 'dhy', 'height': 180}

[3]clear()

使用clear方法可以清空字典中的所有键值对

dict_one = {'name': 'dhy', 'age': 18, 'height': 180}
dict_one.clear()
print(dict_one)  # {}

[4]popitem

删除字典中结尾的一个键值对，并以元组的形式返回被删除的键值

dict_one = {'name': 'dhy', 'age': 18, 'height': 180}
print(dict_one.popitem())  # ('height', 180)
print(dict_one)  # {'name': 'dhy', 'age': 18}

（6）keys()键对

使用keys方法可以获取字典里所有的键

dict_one = {'name': 'dhy', 'age': 18, 'height': 180}
print(dict_one.keys())  # dict_keys(['name', 'age', 'height'])

（7）values()值对

使用values方法可以获取字典中所有的值

dict_one = {'name': 'dhy', 'age': 18, 'height': 180}
print(dict_one.values())  # dict_values(['dhy', 18, 180])

（8）items()键值对

使用item方法可以获取字典中所有的键值对

dict_one = {'name': 'dhy', 'age': 18, 'height': 180}
print(dict_one.items())  # dict_items([('name', 'dhy'), ('age', 18), ('height', 180)])

（9）遍历循环

可以遍历字典，但是遍历字典出来的是键

dict_one = {'name': 'dhy', 'age': 18, 'height': 180}
for i in dict_one:
    print(i)

可以遍历字典的键值对，根据解压赋值

dict_one = {'name': 'dhy', 'age': 18, 'height': 180}
for k,v in dict_one.items():
    print(k,v)

（10）sorted()字典排序

字典的排序是通过字典的键来进行的

dict_one = {'name': 'dhy', 'age': 18, 'height': 180}
print(sorted(dict_one))  # ['age', 'height', 'name']

【五】布尔类型（bool）

（1）类型强转

代表真的情况：
- 数字类型（有值的数字类型都是真）、有值的字符串/列表/字典/元组/集合

num = 1
print(bool(num), type(bool(num)))  # True <class 'bool'>

代表假的情况：
- 数字类型0或者空的字符串/列表/元组/字典

num = 0
num_one = ''
print(bool(num), type(bool(num)))  # False <class 'bool'>
print(bool(num_one), type(bool(num_one)))  # False <class 'bool'>

【六】元组类型（tuple）

（1）类型强转

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

name_list = ['dhy', 18]
print(tuple(name_list), type(tuple(name_list)))

（2）索引取值

元组也支持索引取值，只能取不改

name_tuple = ('dhy', 'lqq')
print(name_tuple[0])  # dhy

（3）切片

顾头不顾尾[起始索引:结束索引:step]

name_tuple = ('heart', 'god', 'father', 'tom')
print(name_tuple[0:2])  # ('heart', 'god')

（4）计算长度 len

name_tuple = ('dhy', 'lqq', 'jerry', 'tom')
print(len(name_tuple))  # 4

（5）成员运算

num_tuple = (1, 2, 3, 4)
print(3 in num_tuple)  # True

（6）循环取值

num_tuple = (1, 2, 3, 4)
num_tuple_two = ('a', 'b', 'c')
print(num_tuple + num_tuple_two)  # (1, 2, 3, 4, 'a', 'b', 'c')

【八】集合类型（set）

集合类型的定义使用大括号（），元素之间使用,分隔

（1）类型强转

集合的特点就是无序性

print(set('dhy'))  # {'h', 'd', 'y'}

集合的另一大特性就是去重，去除重复的元素

print(set('dhyy'))  # {'y', 'h', 'd'}

字符串类型可以强转成集合类型
字典也可以去重，一般我们只对字典的值去重

print(set({'name': 'dhy', 'age': 18, 'sex': '男', 'height': 18}.values()))  # {18, '男', 'dhy'}

列表类型可以强转成集合类型

num_list = [1, 2, 3, 4, 5, 6, 6, 6, 6, 6, 6]
print(set(num_list))  # {1, 2, 3, 4, 5, 6}

（2）添加元素

[1]add()

添加单个元素

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

[2]update()

添加多个元素（字符串/列表/字典/元组）
重复的元素会按照集合的特性进行去重

num_set = {1, 2, 3, 4}
num_set.update((1, 2, 5, 6))
print(num_set)  # {1, 2, 3, 4, 5, 6}

（3）删除元素

[1]remove()

只能按照集合中的值删除掉指定元素

num_set = {1, 2, 3, 4, 5, 6}
num_set.remove(1)
print(num_set)  # {2, 3, 4, 5, 6}

（4）集合操作

[1]union()并集

num_set = {1, 2, 3, 4, 5, 6}
num_set_two = {2, 3, 7, 8}
union_set = set.union(num_set, num_set_two)
print(union_set)  # {1, 2, 3, 4, 5, 6, 7, 8}

[2]intersection()交集

num_set = {1, 2, 3, 4}
num_set_two = {2, 3, 7, 8}
union_set = set.intersection(num_set, num_set_two)
print(union_set)  # {2, 3}

[3]difference()差集

方法返回当前集合和其他集合的差集

num_set = {1, 2, 3, 4}
num_set_two = {2, 3, 7, 8}
union_set = set.difference(num_set, num_set_two)
print(union_set)  # {1, 4}

（5）成员运算

虽然集合是无序的，但是不影响判断元素在不在集合里面，在就是True，不在就是False

num_set = {1, 2, 3}
print(1 in num_set)  # True

（6）循环

num_set = {1, 2, 3, 'dhy'}
for i in num_set:
    print(i)
# 1
# 2
# 3
# dhy

（7）计算长度 len()

num_set = {1, 2, 3, 'dhy'}
print(len(num_set))  # 4

JZTXT

基本数据类型

内容概要

今日详细内容

【一】数字类型

【1】整形、浮点型（int/float）

【二】字符串类型

【三】列表类型

【四】字典类型

（1）取值

[1]按[key]

[2]get取值

（2）计算长度 len

（3）成员运算

（4）增加

[1] update(key=value)

[2]setdefault(key,value)

（5）删除

[1]del

[2]pop()

[3]clear()

[4]popitem

（6）keys()键对

（7）values()值对

（8）items()键值对

（9）遍历循环

（10）sorted()字典排序

【五】布尔类型（bool）

（1）类型强转

【六】元组类型（tuple）

（1）类型强转

（2）索引取值

（3）切片

（4）计算长度 len

（5）成员运算

（6）循环取值

【八】集合类型（set）

（1）类型强转

（2）添加元素

[1]add()

[2]update()

（3）删除元素

[1]remove()

（4）集合操作

[1]union()并集

[2]intersection()交集

[3]difference()差集

（5）成员运算

（6）循环

（7）计算长度 len()