数据类型及内置方法1

零、

可变类型：值改变的情况下，id不变
不可变类型：只改变的情况下，id变化
有序：但凡有索引的数据都是有序的

一、整型

用途

存qq号，手机号，不带字母的身份证号码
定义方式

age = 18
可变or不可变

不可变

进制转换

其他进制转十进制

# 二进制转十进制
10 —— 1 * (2 ** 1) + 0 * (2 ** 0)

# 八进制转十进制

235 —— 2 * (8 ** 2) + 3 * (8 ** 1) + 5 * (8 ** 0)

# 十六进制转十进制

217 —— 2 * (16 ** 2) + 1 * (16 ** 1) + 5 * (8 ** 0)

int 可以传第二个参数，表示第一个参数是什么进制，然后转成十进制
```
- print(int('1100', 2))
- print(int('14', 8))
- print(int('c', 16))
```

十进制转其他进制

- 十进制转二进制
  print(bin(12))   # 0b1100
- 十进制转八进制
  print(oct(12))   # 0o14
- 十进制转十六进制
  print(hex(12))   # 0xc

二、字符串

描述
定义方式

‘ ’ “ ” ‘’‘ ’‘’
有序 or 无序

有序
可变 or 不可变

不可变

操作和内置方法

按索引取值

s = 'hello world'
print(s[0])    # h
print(s[-1])    # d

切片（顾头不顾尾）

s = 'hello world'
print(s[0:5])   # hello
print(s[0:10:2])    # hlowr
print(s[5:0:-2])    # le
print(s[-1:-4:-1])    # dlr

len（统计字符个数）
```
s1 = '  '
print(len(s1))    # 2
```
in, not in（判断一个字符串是否存在于一个大的字符串中）
```
print('a' in 'abcd')    # True
```

strip（去掉字符串左右两边的字符）

strip()    # 默认去除字符串首位的空格

name1 = '    byx '
print(name1.strip())    # byx

name2 = '$by$x$'    
print(name2.strip('$'))    # by$x    中间的符号不会去除
print(name2.lstrip('$'))    # by$x$
print(name2.rstrip('$'))    # $by$x

split（将字符串分割成列表）

data = 'byx|18|male'
print(data.split('|'))    # ['byx', '18', 'male']    切分成列表
print(data.rsplit('|', 1))    # ['byx|18', 'male']    从右边切一个'|'

for循环

for i in 'byx':
    print(i, end=' ')    # b y x

lower, upper（大写、小写转换）

s = 'ByX'
print(s.lower())    # byx
print(s.upper())    # BYX
print(s)    # ByX    s 本身没变

startswith, endswith（判断首位）

s = 'byx'
print(s.startswith('b'))    # True
print(s.endswith('x'))    # True

join（拼接）

user_list = ['byx', '18', 'male']
res = '|'.join(user_list)
print(res)    # byx|18|male

replace（替换）

str = 'Rome was not built in one day'
res = str.replace('day', 'month')
print(res)    # Rome was not built in one month
print(str)    # Rome was not built in one day    原字符串没变

isdigit（判断是否输入的数字）

age = input('请输入年龄')
if age.isdigit():    
    age = int(age)
else:
    print('请输入数字')

find，index（寻找位置）

s = 'Rome was not built in one day'
print(s.find('was'))    # 5    返回所在位置
print(s.find('xxx'))    # -1    找不到时，返回 -1
print(s.find('was', 0, 5))    # -1    通过索引限制查找范围，顾头不顾尾
print(s.find('was', 0, 5))    # 5    只有找到整个‘was’时，才不返回-1，并返回5

print(s.index('was', 0, 5))    # 报错    找不到值报错
print(s.index('was', 0, 8))    # 5    只有找到整个‘was’时，才不报错，并返回5

count（统计出现次数）

s = 'Rome was not built in one day'
print(s.count('o'))    # 3

center, ljust, rjust, zfill（居中填充，左填充，右填充）

s = 'byx'
print(s.center(7, '*'))    # **byx**    居中填充，一共7位字符
print(s.ljust(7, '*'))    # byx****    左移后填充，一共7位字符
print(s.rjust(7, '*'))    # ****byx    右移后填充，一共7位字符
print(s.zfill(7))    # 0000byx    左边用0填充，一共7位字符

expandtabs（改变table键空格的个数）

s = 'b\tyx'
print(s)    # b yx
print(s.expandtabs(10))    # b         yx    # table键变为10个空格

captalize, swapcase, title

s = 'RoMe waS nOt BuILT in ONe daY'
print(s.capitalize())    # Rome was not built in one day    字符串首字母大写
print(s.swapcase())    # rOmE WAs NoT bUilt IN onE DAy    大小写转换
print(s.title())    # Rome Was Not Built In One Day    所有单词首字母大写

三、列表

定义：[ ]内存放多个任意元素，以逗号隔开

l = list('abc')
l1 = list({'name': 'byx', 'age': 18})    
print(l)    # ['a', 'b', 'c']
print(l1)    # ['name', 'age']
# 内部是for循环

可变 or 不可变

可变类型
有序 or 无序

有序

操作和内置方法

按索引取值（正向存取+反向存取）

l = [1, 2, 3, 4]
print(l[2])    # 3

l[0] = 5    
print(l)    # [5, 2, 3, 4]    可以通过索引修改元素

切片（顾头不顾尾）

l = [1, 2, 3, 4]
print(l[0:4:1])      # [1, 2, 3, 4]
print(l[0::])    # [1, 2, 3, 4]    默认取到最后，默认步长为1
print(l[5::-1])    # [4, 3, 2, 1]

len（长度）
```
l = [1, 2, 3, 4]
print(len(l))    # 4
```

in 和 not in（成员运算）

l = [1, 2, 3, 4]
print(5 in l)    # False

append, insert, extend（添加元素）

l = [1, 2, 3, 4]
l.append(5)
print(l)    # [1, 2, 3, 4, 5]    尾部添加一个元素

l1 = [1, 2, 3, 4]
l1.insert(2, 5)
print(l1)    # [1, 2, 5, 3, 4]    通过索引在任意位置添加一个元素

l1 = [1, 2, 3, 4]
l2 = [5, 6]
l1.extend(l2)
print(l1)    # [1, 2, 3, 4, 5, 6]    列表拼接

l3 = [1, 2, 3, 4]
l3.extend([5,])
print(l3)    # [1, 2, 3, 4, 5]    内部是for循环，参数要传可迭代对象

del, pop, remove（删除）

l = [1, 2, 3, 4]
del l[2]    # del 按照索引删除，适用于所有的删除操作 无返回值
print(l)    # [1, 2, 4]
del l    # 删除列表

l = [1, 2, 3, 4, 5]
l.pop()
print(l)    # [1, 2, 3, 4]    尾部弹出一个参数
res = l.pop()
print(res)    # 4    弹出的元素就是返回值
print(l)    # [1，2, 3]
res1 = l.pop(1)
print(res1)    # 2    可以按照索引指定弹出元素

l = [1, 2, 3, 4]
l.remove(3)
print(l)    # [1, 2, 4] 指定删除元素，无返回值

count（计数）

l = ['a', 'b', 1, 3, 3]
print(l.count(3))    # 2
print(l.count('c'))    # 0

clear（清空）

l = [1, 2, 3, 4]
res = l.clear()
print(l)    # []
print(res)    # None    列表被清空

sort, reverse（排序和反转）

l = [2, 1, 5, 4, 3]
l.sort()
print(l)    # [1, 2, 3, 4, 5]

l = [2, 1, 5, 4, 3]
l.sort(reverse=True)
print(l)     #[5, 4, 3, 2, 1]

队列和堆栈

队列（先进先出）

l1 = []
# 先进
l1.append('a')
l1.append('b')
l1.append('c')
# 先出
print(l1.pop(0))    # a
print(l1.pop(0))    # b
print(l1.pop(0))    # c

堆栈（先进后出）

l1 = []
# 先进
l1.append('a')
l1.append('b')
l1.append('c')
# 先出
print(l1.pop())    # c
print(l1.pop())    # b
print(l1.pop())    # a

数据类型及内置方法1

猜你喜欢