Python之基本数据类型及内置方法

Posted 2020-11-27 码苟jim

Python之基本数据类型及内置方法

数字类型

整型

1.作用

年龄/id

2.定义方式

x = 10

3.使用方法

+ - * / % // ** < <= > >= == !=

4.有序or无序

有索引的就有序，无索引的就无序

压根就没有有序无序一说

5. 可变or不可变

值变id不变叫可变，值不变id变叫不可变

整型不可变

x = 10
print(id(x))
x += 1
print(id(x))

浮点型

1.作用

 薪资

2.定义方式

x = 10.1

3.使用方法

+ - * / % // ** > >= < <= == !=

4.有序or无序

压根没有有序无序一说

5. 可变or不可变

不可变      

x = 10.1
print(id(x))
x +=1
print(id(x))

字符串类型

1.作用

姓名

2.定义方式

单引号/双引号/三单引号/三双引号

3.使用方法

# 优先掌握

# 左    右
s=‘nick handsome‘
#  0123

# 索引
print(s[1])

#索引切片
print(s[0:4])  # 顾头不顾尾
print(s[0:4:2])  # 2表示步长，隔一个取一个
print(1, s[4:0:-1])  # +从左到右，-表示从右到左
print(1, s[2:])  # 左边的不写取到最左边，右边的不写取到最右边

#for循环
for i in s:
    print(4, i)

#成员运算
print(‘nick‘ in s)
print(‘nick1‘ not in s)  # True

#strip()  默认去除两端空格，可以指定去除的字符，可以指定多个字符同时去掉
s1 = ‘a  nick   ******‘
print(s1.strip(‘ kc*‘))  # 可以乱序，但是不能没有

#split() # 切割
s2 = ‘nick|123658|180|140‘
print(s2.split(‘|‘))  # 按照|切割字符串，得到的是一个列表

#len()长度
s1 = ‘nick handsome‘
print(len(s1))

# 掌握

# lstrip&rstrip
s3 = ‘**nick**‘
print(s3.lstrip(‘*‘))
print(s3.rstrip(‘*‘))

# lower&upper
s3 = ‘Nick‘
print(s3.lower())  # 小写
print(s3.upper())  # 大写

# startswith&endswith
s4 = ‘nick handsome‘
print(s4.startswith(‘nick‘))  # 以。。。开始
print(s4.endswith(‘some‘))  # 以。。。结束

# rsplit
s = ‘nick|handsome|180|140|‘
#    01234
# print(‘range(len(s))‘,range(len(s)))
# lt = []
# ind = -1
# for i in range(len(s)):
#     if s[i] == ‘|‘:
#         lt.append(s[ind+1:i])
#         ind = i # ind = 4
#
# print(‘lt‘, lt)

print(s.split(‘|‘,1))
print(s.rsplit(‘|‘,1))  # 从右切割

# join
s = ‘nick|handsome|180|140‘
lt = s.split(‘|‘)
print(lt)
# 用*拼接列表内的每一个元素
# new_s = ‘‘
# for i in lt:
#     i += ‘*‘
#     new_s += i
# print(new_s)
print(‘*‘.join(lt))  # 使用*拼接列表内的每一个元素

# replace
s = ‘nick handsome‘
s = s.replace(‘nick‘,‘nick chen‘)
print(s)

# isdigit/isalpha
s = ‘a123123‘
print(s.isdigit())  # 判断字符串内字符是否都为数字
s = ‘askdlfj234‘
print(s.isalpha())
# pwd = input(‘请输入你的密码：‘)
# if not pwd.isdigit():
#     print(‘请输入纯数字‘)

## 了解

# find|rfind|index|rindex|count
s = ‘nick handsome‘
print(s.find(‘h‘))  # 找索引,-1表示没找到
print(s.rfind(‘h‘,6,10))

print(s.index(‘h‘))
# print(s.index(‘sadf‘))  # 找不到报错
# print(s.find(‘sadf‘))  # 找不到返回-1

s = ‘aaaaacccc‘
print(s.count(‘a‘))

# center|ljust|rjust|zfill
s = ‘nick‘
print(s.center(50,‘*‘)) # 居中
print(s.ljust(50,‘*‘))
print(s.rjust(50,‘*‘))
s = ‘111‘
print(s.zfill(8))

# expandtabs
# 
 换行
# 	 缩进
s = ‘a				a‘
print(s)
print(s.expandtabs(18))

# captalize|swapcase|title
s = ‘nickNick handsome‘
print(s.capitalize())  # 首字母大写
print(s.swapcase())
print(s.title())  # 每个单词的首字母大写


# is系列

4.有序or无序

有序

5. 可变or不可变

不可变
s = ‘nick‘
print(id(s))
s += ‘nick‘
print(id(s))

列表

1.作用

存储多个值

2.定义方式

[]用逗号隔开多个元素

3.使用方法

# 优先掌握

# 1. 索引取值/索引修改值
lt = [1, 2, 3, 4]
print(lt[1])
# lt[1] = 3
# print(lt)

# 2. 切片
print(lt[:])
print(lt[1:2])
print(lt[1:4:2])

# 3. for循环
for i in lt:
    print(i ** 2)

# 4. 成员运算
print(1 in lt)
print(5 in lt)

# 5. len
print(len(lt))

# 6. append()
lt.append(5)
print(lt)

# 7. del删除
print(lt)
# del lt[0]
# print(lt)

# insert
lt = [1, 2, 3, 4, 5]
lt.insert(0, 0)  # 往前插入
print(lt)

# pop:按照索引删除值
lt = [11, 22, 33, 44, 55]
lt.pop(0)
print(lt)

# remove：按照值删除值
lt.remove(22)
print(lt)

# count：计数
lt = [11, 11, 11, 22]
print(lt.count(11))

# index：寻找值的索引
print(lt.index(11))  # 找到了就返回

# clear：清空列表
lt = [1, 2, 2, 3]
lt.clear()
print(lt)

# copy：拷贝列表
lt = [1, 2, 3, 4]
lt1 = lt.copy()
print(lt1)

# extend: 扩展列表
lt1 = [1, 2, 34]
lt2 = [1, 1, 2, ]

lt1.extend(lt2)
print(lt1)

# reverse：反转列表
lt = [1, 2, 3, 4]
lt.reverse()
print(lt)

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

4.有序or无序

有序

5. 可变or不可变

可变

lt = [1, 2, 3]
print(id(lt))
lt.append(4)
print(id(lt))

元组

只可取不佳而更改的列表

1.作用

# 元组一创建就被写死了， 定义元组--》占用内存小 --》 写死了

2.定义方法

（）内用逗号隔开多个元素
# lt =list([1,2,3])
tup = tuple((1, 2, 3))
print(tup, type(tup))

# 如果元组只有一个元素，必须得加逗号
tup1 = (1,)
print(tup1, type(tup1))

3.使用方法

# 1. 索引取值
print(tup[0])
# 2. 索引切片
print(tup[0:3])
# 3. for循环
for i in tup:
    print(i)
# 4. 成员运算
print(0 in tup)
# 5. len长度
print(len(tup))
# 6. index获取元素索引
print(tup.index(1))
# 7. count 计数
print(tup.count(2))

4. 有序or无序

有序

5. 可变or不可变

压根不存这一说

字典

1.作用

 存储多个数据，对每个数据具有描述

2.定义方法

{}内用逗号隔开多个键key(具有描述意义，不能为可变数据类型):值value（任意数据类型）对  # 散列表（哈希表）

dic = {‘name‘: 1}
print(dic)

# 0001
dic = {0: ‘功能1‘, 1: ‘功能2‘}
print(dic)

dic = {[1, 2]: ‘a‘}  # 可变==不可哈希，不可变==可哈希
print(dic)

3.使用方法

# 优先掌握
# 1. 按key取值/按key修改值
dic = {‘a‘: 1, ‘b‘: 2, ‘c‘: 3}

print(dic[‘a‘])

dic[‘b‘] = 4

print(dic)

# 2. 添加值,没有就添加，有就修改
dic[‘d‘] = 4
print(dic)

# 3. for循环
for i in dic:
    print(i)

# 4. 成员运算
print(‘a‘ in dic)

# 5. len长度
print(len(dic))

# 6. keys/values/items
print(dic.keys())  # 看成列表
print(dic.values())  # 获取所有值

print(dic.items())
for i in dic.items():
    print(i)
for kasdfsad, vsdfsdf in dic.items():  # 解压缩
    print(kasdfsad, vsdfsdf)

# 掌握

# get:获取
s = ‘e‘
# print(dic[s])  # KeyError: Nonetype --> s是None，并不是你想象的e
print(dic.get(‘b‘, 1))  # 字典中没有返回None,可以给定一个默认值

# update : 更新，等同于list里的extend
dic1 = {‘a‘: 1, ‘c‘: 2}
dic2 = {‘b‘: 1, ‘d‘: 2}
dic1.update(dic2)
print(dic1)

# fromkeys
print(dict.fromkeys(dict.fromkeys([1, 2, 3, 4])))  # 默认给None

# setdefault  # 字典有这个key，就不修改，没有则增加
dic.setdefault(‘j‘, 2)
dic.setdefault(‘a‘, 2)
print(dic)

4. 有序or无序

无序

5. 可变or不可变

可变

散列表（哈希表）

# 散列表/哈希表存储数据 --》 相比较列表，插入/删除数据更快

# 1. 首先对key做了哈希处理(能对所有数据类型都可以哈希处理)：梅森旋转算法（生成伪随机数）--> 通过哈希处理对于每个key他都可以生成一个序列（永不重复，相同的东西进入哈希处理，结果相同）

import hashlib

m = hashlib.md5()
# m.update(b‘a‘)  # 0cc175b9c0f1b6a831c399e269772661
# m.update(b‘b‘)  # 92eb5ffee6ae2fec3ad71c777531578f
# m.update(b‘c‘)  # 4a8a08f09d37b73795649038408b5f33
# m.update(b‘d‘)  # 8277e0910d750195b448797616e091ad
m.update(b‘a‘)  # 0cc175b9c0f1b6a831c399e269772661
print(m.hexdigest())



# 2. 使用哈希函数对刚刚生成的序列（纯数字）,对纯数字除9取余（0，1，2，3，4，5，6，7，8）


‘‘‘ 
key 哈希处理 纯数字序列 哈希函数  哈希值
‘a‘ --》     12          --》     3
‘b‘ --》     14          --》     5
‘c‘ --》     24          --》     6
‘d‘ --》     21          --》     3
‘‘‘

# 1. 为什么key是不可变数据类型
dic = {‘a‘: 1, ‘b‘: 2, ‘c‘: 3, ‘d‘: 4}
# dic[‘a‘]

# 2. 为什么key不能重名
dic = {‘a‘:1, ‘a‘:2}  # key不能重名
print(dic[‘a‘])


# 3. 字典为什么是乱序的


# 4. 散列表（哈希表）解决了什么问题

集合

交集/并集/补集/差集 
∩ ∪

1.作用

 1。进行上述运算 2. 去重 3.乱序 ---》基于散列表实现的

2.定义方法

{}内以逗号隔开多个元素（不能可为变数据类型）

# s = {}  # 空字典
print(type(s))
# s = set()  # 空集合  # 上面定义了一个相同的变量但是从未使用，你又定义了这个变量
print(type(s))

# inp = input(‘enter‘)
# s = {}
# if inp > ‘11‘:  # 字符串比较，先比较第一位数字，然后再比较第二位数字
#     s +=1
# else:
#     print(s)

s = {‘a‘, ‘a‘, ‘a‘, ‘a‘, 1, ‘v‘, 2, 2, ‘c‘, 3, 3, 4, 5, 6}  # 对于数字而言，不会乱序；但是对于其他，就乱序
print(s)

3.使用方法

# 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


# add（*******）
pythoners.add(‘oscar‘)
print(pythoners)

# pythoners.remove(‘oscar1‘)  # 没有报错
# print(pythoners)
# pythoners.discard(‘oscar1‘)  # 没有不报错
# print(pythoners)

pythoners.pop()  # 随机删除一个
print(pythoners)

# 去重（有局限性）
# 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‘}
]

# 1.长度
>>> s={‘a‘,‘b‘,‘c‘}
>>> len(s)
3

# 2.成员运算
>>> ‘c‘ in s
True

# 3.循环
>>> for item in s:
...     print(item)
... 
c
a
b

4. 有序or无序

无序

5. 可变or不可变

可变  
set = {1, 2, 3}
print(id(set))
set.add(4)
print(id(set))

数据类型总结

存值个数

# 存一个值：整型/浮点型/字符串
# 存多个值：列表/元组/字典/集合

有序和无序

# 有序：字符串/列表/元组（序列类型）
# 无序：字典/集合

可变or不可变

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

# 可变：列表/字典/集合
# 不可变：整型/浮点型/字符串/元组