Python基础—基本数据类型

一、基本数据类型

1.数字

概念：与数学中数字的定义一样。

在python3中支持的数字类型：

• int--整型
• float--浮点型
• bool--布尔型
• fractions--分数
• complex--复数

数字常用方法：

• type()用来判断某个值的类型

print(type(6))
---> int

• isinstance(a,类型名)：判断a是不是某个类型　　

print(isinstance(3,int))
---> True

2.字符串string

概念

凡是用单引号、双引号、三个单引号、三个双引号引起来的内容就是字符串。

字符串的特点：可哈希，也就是不可变数据类型。

字符串的索引：每个字符都有对应的号码，正向从0开始递增，逆向从-1开始递减。

s = 'pythonisinteresting'

s1 = s[0]
print(s1,type(s1))
s2 = s[2]
print(s2)

字符串的切片：通过索引（切片）出来的内容都是字符串类型。切片的方式是一个前开后闭的范围

s = 'pythonisinteresting'

s1 = s[:6] # 从0开始可以省略不写
print(s1)
s2 = s[6:9]
print(s2)
s3 = s[:] # 从头取到尾
print(s3)
s4 = s[6:]
print(s4)

切片+步长方式

s = 'pythonisinteresting'

s5 = s[:5:2]
print(s5)

字符串的常用操作

• str.capitalize 首字母大写 **

s = 'taiBai'

s1 = s.capitalize()
print(s1)
print(s)

• str.upper() 字符串大写     str.lower() 字符串小写

s = 'AbcD'

s1 = s.upper()
s2 = s.lower()
print(s1)
print(s2)

• str.center(长度，填充内容）把字符串以填充内容填充到指定长度

s = 'abc'

s3 = s.center(20, '*')
print(s3)

• str.swapcase() 把字符串的字母大小写反转

s = 'taiBai'
s4 = s.swapcase()
# print(s4)

• str.strip() 去掉字符串两侧的空格,加参数去掉指定内容。
• str.lstrip() 去掉左侧空格，str.rstrip() 去掉右侧空格

s = '    alex\n'
s = '\talex\n'
# print(s)
s6 = s.strip()
print(s6)

# 去掉指定内容
s = 'qw*awle@xyt@'
# 可设置去除的字符
s6 = s.strip('qyt@w*')
print(s6)

• str.split() 默认按照空格分隔，指定字符时，按照指定字符分隔，并将分隔后的元素放入一个列表并返回

s = '武大 小潘 西门'
l = s.split()
print(l)

指定字符分割。
s = '武大,小潘,西门'
# l = s.split(',')
print(l)

指定分割次数
s = '武大a小潘a西门'
rsplit() 从右边开始分割
print(s.split('a',1))

• 连接符.join(iterable)      注：操作列表时，列表里面的内容必须全部是字符串类型

l1 = ['wusir', 'alex', 'taibai']
s7 = ','.join(l1)
print(s7)

• str.startswith() ***判断以什么为开头 可以切片。
• str.endswith()  判断是否以什么结束，可以切片

s = 'alextaibai'
s8 = s.startswith('a')
s9 = s.endswith('i)

print(s8,s9)  True True

• str.find ：通过元素获取其索引,找到第一个就返回,找不到会返回-1.

s = 'taibai'
s1 = s.find('a')

• str.index：通过元素获取其索引,找到第一个就返回，找不到会报错。 　　 

s = 'taibai'
s1 = s.index('W')

• str.replace(old, new) 替换字符串中的元素

s = 'alex 是一个很nb的人，非常nb，太nb了'
s10 = s.replace('nb', 'sb')
s10 = s.replace('nb', 'sb', 2)
print(s10)

• isdigit()判断是不是数字组成
• isalpha()判断是不是字母组成

3.bool类型

python中用来表示逻辑运算结果的值，只有True和False两种。

不同数据类型和bool类型的对应关系

str ---> bool  非空即True

数字 ---> bool 除0为False外，其他都为True

二、组合数据类型

1.列表 list

列表概念

一种序列类型的数据，十分常用

特点：

• 使用[]或list()创建，逗号分隔
• 较字符串对比可以存储大量数据

列表的索引和切片

• list[m]：获取列表中索引为m的元素，返回的类型是元素的本身类型
• list[m:n:k]：返回一个列表，其中元素是根据步长获取的列表中的元素
• list[m:n]：返回一个列表，其中元素是列表中索引从m到n但不含n的元素
• list += lt：更新list，将lt元素增加到list中

列表的增删改查

列表的增

1.append 单个追加到列表末尾
li.append('lulin')
li.append(['10', 2, '3'])

2.insert 插入，按照索引位置插入值
li.insert(1, 'lulin')

2.extend 追加可迭代对象，将可迭代对象拆分为单个元素添加至列表后面
li.extend('asdfn')
li.extend([1, 2, 5, 's'])
li.extend(11) 会报错，数字不可迭代。

列表的删

1 pop 按照索引删除，不指定索引会删除最后一个，最后会将删除的元素做为返回值返回
ret = li.pop(0)
print(ret)

2 remove 指定元素删除,如果元素有多个，只删除第一个元素,没有返回值
li.remove('ryxiong')

2 clear 清空列表,返回一个空列表，也就是原列表清空但没有删除，返回回来
li.clear()
print(li)

4 del 根据索引、切片（步长）、删除，或删除整个列表,在内存中清除此列表
del li[0]
del li[1:4:2]
del li

列表的改

1.改动某个索引元素
li[0] = 'nanshen'

2.按切片改动
li[:3] = 'abc'
li[:3] = 'asdfnlasnfd' # 说明切片改动类似可迭代改动，清空切片位置，添加元素个数不定，可多可少

3.安切片（步长）改动，切片长度与重新添加元素个数必须一一对应
li[1:4:2] = 'a' # 错误
li[1:4:2] = 'ab'
li[1:4:2] = [1, 2, 3] # 错误

列表的查

# 查
1 按照索引，按照切片（步长）查询
2 for循环
    for i in li:
        print(i)
print(li)

 列表的其他操作方法

• list.sort() 将列表中的元素排序，根据ascii编码对应的数字排序
• list.reverse() 将列表中的元素反转，需要查看列表看反转结果
• list.index(x) 返回元素x在list中的索引，没有就报错
• list.count(x) 返回元素x在列表中出现的次数。
• list.copy() 返回一个列表的副本，浅拷贝

2.元组类型 tuple

概念：一种不可修改的序列类型

特点：

• 创建后不可修改
• 使用小括号或tuple()创建
• 可使用或不适用小括号

tu1 = (1, 'alex', [1,2,3], True)
# 可索引，切片
print(tu1[1])
print(tu1[:3])

# 元组只能查不能改
# 特点：元素的元素不能进行复制，如果元素是可变数据类型，可以修改该元素
# 索引，切片（步长） 查询
for i in tu1:
    print(i)

元组类型的操作：继承序列类型的所有通用操作

定义后无法修改，没有特殊操作

使用或不使用小括号

# 元组当真不能改么？？？
tu1 = (1, 'alex', [1,2,3], True, (1,2,3))

# 儿子不能改，孙子可能改。
tu1[2].append('太白')
tu1.append(666)
print(tu1)

使用场景

一般用于记录比较重要的不可修改的数据，如初始坐标扽等

3.字典类型 dict

字典概念

映射：一种键（索引）和值（数据）的对应，字典是映射的体现。

键值对：键是数据索引的扩展，字典是键值对的集合，键值对之间无序，采用大括号{}和dist()创建，键值对用":"表示。

表现形式：{<键1>:<值1>,<键2>:<值2>,...<键n>:<值n>}

字典的增删改查

字典的增加

dic = {
    'name': '太白金星',
    'age': 18,
    'hobby': 'wife',
}

1.有责修改，无则添加

dic['hight'] = 176
dic['age'] = 23
print(dic)

# 结果
dic = {
    'name': '太白金星',
    'age': 23,
    'hobby': 'wife',
    'height': 176,
}

2.有则不变，无则添加

# 原理：先查找键，如果字典中有，返回对应的值，如果不在，返回none，根据返回值，如果不为空，则不变，如果为空，在添加键值对
print(dic.setdefault(2, 5)) # 打印的结果为5，即setdefault会返回值。
dic.setdefault('weight')  # {'name': '太白金星', 'age': 18, 'hobby': 'wife', 'weight': None}
dic.setdefault('weight',160)  # {'name': '太白金星', 'age': 18, 'hobby': 'wife', 'weight': 160}
dic.setdefault('name','barry')  # {'name': '太白金星', 'age': 18, 'hobby': 'wife'}

字典的删除

dic = {
    'name': '太白金星',
    'age': 18,
    'hobby': 'wife',
}

1.pop按照键删除

ret = dic.pop('age')  # 按照键删除掉键值对
print(ret)
# dic.pop('age1')  # 没有报错
ret = dic.pop('age1', '没有此键')  # 设置两个参数，第二个参数是提示语 一般设置成None

print(ret)  # 没有此键
print(dic)  # {'name': '太白金星', 'hobby': 'wife'}

2.clear清空

dic.clear()
print(dic)  # {}

3.popitem()删除，3.6版本之后就是删除最后一个键值对

ret = dic.popitem()
print(ret)  # ('hobby', 'wife')
print(dic)  # {'name': '太白金星', 'age': 18}

4.del指定键删除

del dic['name']  # 按照键删除
print(dic)  # {'age': 18, 'hobby': 'wife'}
# del dic['name1']  # 键不存在报错，keyError
del dic  # 删除字典

字典的修改

dic = {
    'name': '太白金星',
    'age': 18,
    'hobby': 'wife',
}

1.指定键直接修改

dic['age'] = 30
print(dic)  # {'name': '太白金星', 'age': 30, 'hobby': 'wife'}

2.update()指定键值对修改，键存在则修改，键不存在则添加

dic.update(name="ryxiong")  # 键存在
print(dic)  # {'name': 'ryxiong', 'age': 18, 'hobby': 'wife'}

dic.update(gender="male")  # 键不存在
print(dic)  # {'name': 'ryxiong', 'age': 18, 'hobby': 'wife', 'gender': 'male'}

3.update()指定字典更新，有的键会覆盖，没有的键会添加。

dic = {"name": "jin", "age": 18, "sex": "male"}
dic2 = {"name": "alex", "weight": 75}
dic2.update(dic)
# 将dic里面的键值对覆盖添加到dic2中
print(dic)  # {'name': 'jin', 'age': 18, 'sex': 'male'}
print(dic2)  # {'name': 'jin', 'weight': 75, 'age': 18, 'sex': 'male'}

字典的查找

1.直接通过键查找

print(dic['age'])
print(dic['age1'])  # 没有报错

2.通过get方法查找

# 有的返回对应的值
print(dic.get('age'))  # 18
# 没有此键默认返回None
print(dic.get('age1'))
# 可以设置没有找到时返回的返回值
print(dic.get('age1', '没有此键'))

字典的其他操作方法

# dict.fromkeys(iter,x)
# 传入一个可迭代对象，将这个可迭代对象的每个元素当成字典的键，将后面的参数作为每个键的值，构建一个列表并返回。

dic = dic.fromkeys('adfa', 'ryxiong')
dic = dic.fromkeys('abcd,', [1,])

4.集合类型 set