python 六种基本数据类型的一种通俗易懂的解释，及其举例使用

Python语言共有六种数据类型：Number(数字)、String(字符串)、List(列表)、Tuple(元组)、Dictionary(字典)、Set(集合)

用法比较多的有List(列表)，Dictionary(字典)和Set(集合)

1. 数字类型(number)：

 

# int 整型
a = 1
type(a)    # --> <class 'int'>

# float 浮点型
b = 1.0
type(b)    # --> <class 'float '>

# bool 布尔型，即True和False
c = True
type(c)    # --> <class 'bool '>


# 布尔型的补充，几种python默认为True或者False的例子
a = True
if a:    # True
    print(111)    # --> 111

a = 1
if a:    # True
    print(111)    # --> 111

a = ''
if a:    # False
    print(111)    # --> 

a = []
if a:    # False
    print(111)    # --> 

a = 0
if a:    # False
    print(111)    # --> 


# 复数型使用较少，暂不介绍

2. 字符串(string)：

# 字符串：用英文单引号，双引号或者三引号表示字符串，一般用' '和" ", 三引号''' '''常用作备注
name = "尼古拉斯赵四"
name = '尼古拉斯赵四'
name = '''尼古拉斯赵四'''
# 如果字符串里面的内容有单引号，表示字符串就不能用单引号，而应该用其他两种
name = " 尼古拉斯'赵四' "
name = ' 尼古拉斯"赵四" '
type(name)                   # --> <class 'str'>

'''字符串拼接'''
name = "尼古拉斯赵四"
print(name + '很搞笑')        # --> 尼古拉斯赵四很搞笑

'''转义''' # \n用于举例，表示打一个换行
name = "尼古拉斯赵四"
print(name + '\n' + '123')   # --> 尼古拉斯赵四
                             #     123

'''取切片：从字符串中截取一部分'''
name = "尼古拉斯赵四"
print(name[0:3])            # --> 尼古拉  (取第0，1，2个字符，[0:3]指左闭右开)
print(name[0])              # --> 尼

print(name[-4:])            # 拉斯赵四    (取倒数第4个到结尾)
print(name[0:-1:2])         # 尼拉赵   (输出第一个至倒数第二个的字符，步长为2)

3. 列表(list)：

1 创建一个空列表

2 创建存储元素的列表

3 列表中修改元素值

'''列表list'''
# 1 创建一个空列表
list_a = []

# 2 创建存储元素的列表
list_b = [11,22,33,44,55,66]

# 3 列表中修改元素值
list_b = [11,22,33,44,55,66]
list_b[0] = 0
print(list_b)     # [0, 22, 33, 44, 55, 66]

4 列表排序

# 4 列表排序
list_b = [22,11,33,66,55,44]
list_b_sorted = sorted(list_b)              # 从小到大排序
list_b_sorted = sorted(list_b,reverse=True) # 反向排序

# 高阶函数排序
list_b = [22,11,33,66,55,44]
list_b_sorted = sorted(list_b,key=lambda x: -x) # 通过lambda函数传入作为排序的键，以每个元素的相反数为键排序

5 删除元素

# 5 列表中删除元素
# remove 
list_b.remove(11) # 删除指定值的元素，每次只能删一个
print(list_b)     # [22,33,44,55,66]

# pop 
list_b = [11,22,33,44,55,66]
list_b.pop(0)	# 删除指定索引位置的元素，每次只能删一个
print(list_b)   # [22, 33, 44, 55, 66]

list_b = [11,22,33,44,55,66]
list_b.pop()   	# pop()不设置索引值时默认删除最后一个
print(list_b)   # [11, 22, 33, 44, 55]

6 列表的切片索引

# 6 列表的切片索引
list_b = [11,22,33,44,55,66]
list_b[0]           # 11 取第一个元素
list_b[:3]          # [11, 22, 33]  取前三个元素
list_b[0:-1:2]      # [11, 33, 55]  从0位置到倒数第一个位置每隔2个取

7 列表添加元素和循环

# 7 列表添加元素和循环
list_b = [11,22,33,44,55,66]
list_b.append('abc')        # list.append()方法可以向list末尾添加一个元素，可以是任意类型的元素
                            # [11, 22, 33, 44, 55, 66, 'abc']
list_b.append(77)           # [11, 22, 33, 44, 55, 66, 'abc', 77]
list_b.append([1,2,3])      # [11, 22, 33, 44, 55, 66, 'abc', 77, [1, 2, 3]]
list_b.extend([1,2,3])      # list.extend(list2)会把list2中的每个元素添加到list中
                            # [11, 22, 33, 44, 55, 66, 'abc', 77, [1, 2, 3], 1, 2, 3]
list_b.insert(1,'aaa')      # list.insert(index, object)在list的index位置添加object元素
                            # [11, 'aaa', 22, 33, 44, 55, 66, 'abc', 77, [1, 2, 3], 1, 2, 3]
# 利用循环添加元素是一种常见缓存数据的方法
# 循环向列表添加元素
list_c = []
for i in range(10):
    list_c.append(i)
print(list_c)               # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 复写列表中的元素，如每个元素乘以2
list_c = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
for i in range(len(list_c)):
    list_c[i] = list_c[i]*2
print(list_c)               # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]


'''列表高阶操作-推导式'''
list_c = [i for i in range(10)]
# 等价于
list_c = []
for i in range(10):
    list_c.append(i)
print(list_c)           # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

list_c = [(i*2 if i >= 5 else i*3) for i in range(10)]
# 等价于
list_c = []
for i in range(10):
    if i >= 5:
        list_c.append(i*2)
    else:
        list_c.append(i*3)
print(list_c)           # [0, 3, 6, 9, 12, 10, 12, 14, 16, 18]

4. 字典(dict)：

'''字典dict'''
# 字典存储数据通过键值对，就像字典一样，{'姓名':'赵四'}
#                                    {key: value}, key不可重复，必须唯一，而值value是可重复的

# 创建和赋值，更新
d = {}
d['name'] = '赵四'      # {'name': '赵四'}
d['score'] = 100        # {'name': '赵四', 'score': 100}
d['score'] = 120        # {'name': '赵四', 'score': 120}
d.update({'name': '张三', 'score': 90, 'course': '语文'})
                        # {'name': '张三', 'score': 90, 'course': '语文'}
# 取值
d.keys()                # dict_keys(['name', 'score', 'course'])
d.values()              # dict_values(['张三', 90, '语文'])
d.items()               # dict_items([('name', '张三'), ('score', 90), ('course', '语文')])
d.get('course','新课程')   # 如果能取到course的值，则取值；取不到值则返回'新课程'，这里返回'语文'
d.get('course_new','新课程')    # 因为d里面没有course_new这个键，所以返回'新课程'

5. 集合(set)：

'''
集合set 用set()或者{}表示
可变
无序
不可重复--最基本的功能为可以用来去重
'''
# 创建
a = set()
type(a)     # <class 'set'>
a = {1,2,3,4,5}
type(a)     # <class 'set'>
a = {'111','111','111',5,5,2,2,2,2}
print(a)    # {2, 5, '111'} -- 由于set是不可重复的，自动去重，且结果是无序的

# 删除元素
a = {1,2,3,4,5}
a.remove(2) # 删除 2 这个元素
a.pop()     # 随机删除一个元素
a.clear()   # 清空a的元素，变为空集合

# 集合间运算  交并
s1 = {1,2,3}
s2 = {2,3,4}
print(s1 & s2)  # 交集{2, 3}
print(s1 | s2)  # 并集{1, 2, 3, 4}
print(s1 - s2)  # 差集{1}  即属于s1且不属于s2的元素
print(s1 ^ s2)  # 对称差集{1, 4} 即s1不属于s2的元素和s2不属于s1的元素

6. 元组(tuple)： 

'''
元组tuple  用()表示
有序且不可变，可重复
'''
# 创建
a = (1,)
a = (1,2,3)
type(a)     # <class 'tuple'>

# 切片索引
a = (1,2,3)
a[1:3]      # (2, 3)

# 循环遍历
for i in a:	
    print(i)    # 1 2 3