数据类型

数据类型

1.Number[整型,浮点型,复数]

2.String:字符串

3.Boolean:布尔值[True,False]

4.None:空值

5.List:列表

6.Set:集合

7.Tuple:元组

8.Dict: 字典

可变数据类型:Dict\Set\List

不可变数据类型: Boolean\Tuple\String\Number

以内存的值是否可以修改,来判定是否可变

Boolean布尔值

使用场景: 主要用于分支和循环语句中

True:1 False:0

b1 = True

b2 = False

print(type(b1))

None空值:

None:python中一种特殊数据类型,和0区分

n = None
print(type(n))

Number数字

1.分类

1.整型

可正可负,处理任意大小的整数

2.浮点型

注意:四舍五入的误差

3.复数

a+bj

2.数字类型转换

int()

float()

complex(x,y)[x是实数,y是虚数]

3.功能

3.1数学功能
import math
# 求绝对值
a1 = -10
print(abs(a1)) 
# 获取最大值
m = [10,8,12,-2]
print(max(m))
# 获取最小值
print(min(m))
# 向上取整
upInt = 18.1
print(math.ceil(upInt))
# 向下取整
downInt = 18.3
print(math.floor(downInt))
# 开平方
sartInt = 100
print(math.sqrt(sartInt))
# 平方
powInt = pow(10,2)
print(powInt)
扩展:
# 遵循银行家舍入
# 46舍入,5看情况,如果5后不全为0,如果5后全为0,看5前边是奇还是偶,如果是奇则进,如果是偶则舍弃
print(round(4.51))
print(round(3.50)) = >4
print(round(4.50)) = >4
print(round(3.62))
3.2随机数
import random
# 随机抽取
l = [3,5,7,10,-2,10.5]
s = "hello"
print(random.choice(s))
# 打乱列表顺序,shuffle就是没有返回值,直接把列表更新
m_random = [1,2,3,4,5,6,7,8,9,10]
random.shuffle(m_random)
# 随机产生一个0-1的数,0-1之间这么一小数
print(random.random())
# 随机产生一个0-10之间的整数
1. print(random.choice(range(1,10)))
2. print(random.randint(1,10))
# random.randrange(start,end,step)
"""
start:开始值,默认为0
end: 结束值,不包含范围内
step: 步长
"""

字符串

# 首字母变大写
s = "hello world"
print(s.title())
# 截取 包起始位置的值,不包含尾部
print(s[0:5])
# 截取e,从2--最后,记住第一个位置下标为0
print(s[1:])
# 全部输出
print(s[:])
#  重复输出
print(s * 2)
# 倒叙输出
print(s[::-1])
字符串索引规律
从左往右,步长递增: 0 
从右往左, 步长递减: -1
# 去除空格
s = " hello.py "
print(s.lstrip()) #l去除左边空格
print(s.rstrip()) #r去除右边空格
print(s.strip())  #strip去除左右两边的空格

转义

需要在字符中使用特殊字符时,python用反斜杠()转义字符。如下表:

\(在行尾时)续行符\\反斜杠符号
单引号"双引号
\n换行\t水平制表符(4个空格)

续行符

myStr = 'abcde\
f'

格式化输出

%d %s %f 占位符

print("num = %d, str19 = %s, f = %.3f" % (num, str19, f))
#%	'%%'输出一个单一的'%'
print("%-10.2f"%22.11111,'modeng') #10 为10个长度 用做左对齐
# 输出结果:      22.11 modeng
print("%10.2f"%22.11111,'modeng')  #10 为10个长度 用做右对齐
# 输出结果: 22.11      modeng

使用format进行格式化

print(“字符串{} 浮点数{} 整数{}”.format(‘asd’,11.1,8))

常见函数

isnumeric() [nu:'merɪk]如果字符串中只包含数字字符,则返回 True,否则返回 False
splitStr.join(Str)以指定字符串作为分隔符,将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
center(self,width,fillchar)以原始字符串为中心生成新字符串
ljust(width,[str])返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串,fillchar 默认为空格。
rjust(width,[str])返回一个原字符串右对齐,并使用 fillchar 填充至长度 width 的新字符串,fillchar 默认为空格。
lstrip()/rstrip()/strip截掉字符串左/右边的空格或指定字符/俩侧
max(str)/min(str)返回字符串 str 中最大/小的字母。
chr(x)将一个整数转换为一个字符
ord(x)将一个字符转换为它的整数值
myStr.replace(old,new[,max])把 将字符串中的 str1 替换成 str2,如果 max 指定,则替换不超过 max 次。
find(str,beg=0,end=len)/index(str)查找某个字符出现的位置 从左侧开始查找 查到返回索引值 查不到返回-1 /查到返回索引 查不到报错
rfind(str,beg=0,end=len)/rindex(str)查找某个字符出现的位置 从右侧开始查找 查到返回索引值 查不到返回-1 /右查到返回索引 查不到报错
split(str=’’[,num])num=string.count(str)) 以 str 为分隔符拆分字符串为列表,如果 num 有指定值,则仅截取 num 个子字符串
swapcase()将字符串中大写转换为小写,小写转换为大写
upper()转换字符串中的小写字母为大写
lower()转换字符串中的写字母为小写
splitlines(True)以回车换行为条件分割,参数用来设置是否保留换行

案例

# 判断一以什么结尾
# 扩展s字符串来源可以改成键盘输入
s = "hello.py"
if s[-3:] == ".py":
    print("你们是最棒的")
else:
    print("我们还需要加强练习")

列表

1.概述

引出:存储一个数据可以采用变量

问题:需要同时存储多个数据,该怎么做?

#需求:有5个人的年龄,求平均年龄
age1 = 10
age2 = 32
age3 = 43
age4 = 18
age5 = 90
average = (age1 + age2 + age3 + age4 + age5) / 5

解决:容器【Python提供了一种数据结构list,可以同时存储多个数据】

本质:一种有序的集合

2.创建列表

语法:列表名 = [列表选项一,列表选项二,列表选项三…]

说明:使用[]表示列表,列表名其实就是标识符

​ 将列表中的列表选项被称为元素

​ 列表中的元素分别被编了号,这些编号被称为索引【下标,角标】,从0开始编号

3.列表中元素的访问

3.1取值

语法:列表名[索引]

list4 = [100,200,400,300,800]
num = list4[2]
print(num)
print(list4[2])
3.2替换

语法:列表名[索引] = 新的元素值

list4[2] = 888
print(num)
print(list4[2])

4.列表操作

#1.列表组合
#直接使用加号
list1 = [43,65,76,6]
list2 = [45,77,90,11,2,4,66]
print(list1 + list2)

#2.列表重复
#直接使用乘号
print(list1 * 4)

#3.判断指定元素是否存在于列表中
#成员运算符:in      not in
#运算的结果为布尔值
list3 = ["hello",False,189,"good"]
print(189 in list3) #True
print(180 not in list3)  #True

#4.列表的截取【分片,切片】
#语法:列表名[开始下标:结束下标],表示获取从开始下标到结束下标之间的元素,结果为一个新的列表
#注意:包头不包尾【前闭后开区间】   [开始下标,结束下标)
list4 = ["hello",False,189,"good",436,54,3,45]
print(list4[2:4])

#获取从指定下标到结尾的列表,包含指定下标
print(list4[3:])

#获取从开头到指定下标的列表,不包含指定下标
print(list4[:6])

5.列表内置功能

语法:列表名.功能()
#一、添加元素
#1.append   在列表结尾添加元素或者新的列表【追加】
list11 = [1,2,3,4,5]
print(list11)
#追加元素
list11.append(100)
print(list11)
#追加列表【将容器和元素一起添加进去】
list11.append([547,76,87])
print(list11)

#2.extend    在列表的末尾一次性追加另一个列表中的元素
list12 = [1,2,3,4,5,100]
list12.extend([547,76,87]) #只将元素添加进去
print(list12)

#3.insert  在指定索引处插入一个元素,不覆盖原来的元素,原有的元素向后顺延
#注意:告诉编译器,需要在什么位置插入什么元素
list13 = [1,2,3,4,5]
print(list13)
#插入元素
list13.insert(2,555)
print(list13)
#插入列表
list13.insert(4,[22,33])
print(list13)

#二、移除元素
#4.pop   移除列表中指定下标的元素
list14 = [1,2,3,4,5,100]
print(list14)
#默认移除最后一个元素
list14.pop()
print(list14)
#移除指定下标的元素
list14.pop(3)
print(list14)

#5.remove  移除元素
list15 = [11,23,354,45,5,100]
#如果元素不存在,则出现错误:ValueError: list.remove(x): x not in list
#list15.remove(3)
list15.remove(5)
print(list15)

#6.clear   清空列表
list16 = [11,23,354,45,5,100]
list16.clear()
print(list16)

#三、获取
#7.index   从列表中查询第一个匹配的元素的下标
list17 = [11,23,354,45,5,100,100,23,354]
print(list17)
#在整个列表中查询
print(list17.index(23))
#只在部分列表中查询【包头不包尾】
#注意:2和7表示开始下标和结束下标,列表下标范围
#print(list17.index(23,2,7))

#获取相关信息,语法:功能()
#8.len 获取列表中元素的个数【获取列表的长度】
list18 = [11,23,354,45,5,100,100,23,354]
#注意:len直接使用
print(len(list18))

#9.max  获取列表中的最大值
print(max(list18))

#10.min  获取列表中的最小值
print(min(list18))

#11.count  查看元素在列表中出现的次数
print(list18.count(23))

#四、反转
#12.reverse  将列表实现倒序
list18.reverse()
print(list18)

#五、排序
#sort和sorted
#13.sorted
list19 = [11,23,354,45,5,100,100,23,354]
#默认实现升序排序
list1 = sorted(list19)
print(list1)
#可以实现降序排序
list2 = sorted(list19,reverse=True)
print(list2)

#通过key关键字来实现排序:根据字符串的长度排序
list20 = ["zoo","manager","hello","jack","international"]
list3 = sorted(list20,key=len)
print(list3)

#14.sort
list19.sort()  #升序
print(list19)
list19.sort(reverse=True)  #降序
print(list19)

#六、拷贝【面试题】
#浅拷贝:引用拷贝
list21 = [1,2,3,4,5]
list22 = list21
print(list21)
print(list22)
list22[2] = 100
print(list21) #[1, 2, 100, 4, 5]
print(list22) #[1, 2, 100, 4, 5]

#拷贝内容
#15.copy([浅拷贝]shallow copy)
list23 = [1,2,3,4,5]
list24 = list23.copy()
print(list23)
print(list24)
list24[2] = 666
print(list23) #[1, 2, 3, 4, 5]
print(list24) #[1,2,666,4,5]

#16.deepcopy([彩蛋][面试分量比较重][深拷贝]deep copy)
import copy
list_remove = [1,2,3,[0,1],5,6,7,4]
deep_list_remove = copy.deepcopy(list_remove)
deep_list_remove[3][0] = 333
print(deep_list_remove)
print(list_remove)
本质:真正获取一个对象的复制实体,而非引用——[记住]

6.多维 列表

实质上还是一个简单列表,只不过列表的元素仍然是一个列表

代码演示:

multiList = [[11,22,33],[100,100],[438,4,4,3,21]]
取值
multiList[0]       # [1,2,3]
multiList[0][0]    # 1

没钱 零买1根 一个变量

稍微有钱 一包 一维列表【20个变量】

条 10包 二维列表【10个一维列表】

6.常见函数

len()计算列表的长度
list.count()统计某个元素在列表中出现的次数
append向列表中添加一个值
list.extend()在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)
list.index()从列表中找出某个值第一个匹配项的索引位置
list.insert(index,obj)将对象插入列表
list.pop()移除列表中的一个元素(默认最后一个元素),并且返回该元素的值
list.remove()移除列表中某个值的第一个匹配项
list.reverse()反向列表中元素
list.sort()对原列表进行排序
list.clear()清空列表
list.copy()复制列表
copy.deepcopy()深拷贝 拷贝对象及其子对象
copy.copy()浅拷贝 只拷贝父对象,不会拷贝对象的内部的子对象

元组(粗略看)

1.概念

元组本质上也是有序的集合,和列表非常相似

区别:

​ a.列表使用[]表示,元组使用()表示

​ b.列表可以修改元素值,但是,元组不可以

注意:元组一旦被初始化之后,就不能发生改变(重要特性,不可变)

2.创建元组

语法:元组名 = (元组元素1,元组元素2,元组元素3…)

#语法:元组名 = (元组元素1,元组元素2,元组元素3....)
#1.创建空元组
tuple1 = ()
print(tuple1)

#2.创建一个带有元素的元组
tuple2 = (22,23,14,87)
print(tuple2)

#3.元组中也可以存储不同类型的数据
tuple3 = ("hello",True,10.24,10)
print(tuple3)

#4.创建只有一个元素的元组(强调)
num = 56
tuple4 = (56,) #只有1个元素的时候必须加一个逗号,来消除歧义

3.元组元素的访问

语法:列表名[索引]

​ 元组名[索引]

tuple1 = (22,23,14,87)
#注意:和列表相同,元素的下标也是从0开始的
print(tuple1[1])
#print(tuple1[4])  #IndexError: tuple index out of range  下标越界

#获取元组中的最后一个元素
print(tuple1[-1])
print(tuple1[-2])
print(tuple1[-3])
print(tuple1[-4])  #第一个元素
#print(tuple1[-5])   #IndexError: tuple index out of range

#修改元组的元素值
#tuple1[1] = 100

tuple2 = (22,23,14,87,[66,77])
#修改列表的元素值
tuple2[4][0] = 888
print(tuple2)

4.元组的操作

#1.元组的连接:+
tuple1 = (2,4,54,6)
tuple2 = (4,6565,87)
print(tuple1 + tuple2)

#2.元组元素的重复:*
print(tuple1 * 3)

#注意:元组的连接和重复最终得到的是一个新的元组

#3.判断指定元素是否在元组中:in
print(45 in tuple1)

#4.元组元素的截取【切片】
#元组名[开始下标,结束下标],注意:包含开始下标,但是不包含结束下标
tuple3 = (2,4,54,6,45,100,56,90)
print(tuple3[1:4])
#从指定下标开始截取到结尾,指定下标包含在内
print(tuple3[3:])
#从开头截取到指定位置,不包含指定下标
print(tuple3[:5])

5.元组功能

#1.获取元组的长度或者计算元组中元素的个数
#len
tuple1 = (23,4,46,5787)
len = len(tuple1)
print(len)

#遍历元组
for index in range(0,len):
 print(tuple1[index])


#2.获取元组中元素的最值
#max   min
max = max(tuple1)
print(max)
min = min(tuple1)
print(min)

#3.列表和元组之间的相互转换
#列表-----》元组
list1 = [23,4,65,76]
print(list1)
new_tuple = tuple(list1)
print(new_tuple)

#元组-----》列表
list2 = list(tuple1)
print(list2)

#自己实现求元组中最大值
max = tuple1[0]

for index in range(0,len(tuple1)):
 if tuple1[index] > max:
     #给max重新赋值
     max = tuple1[index]

6.二维元组

tuple1 = ((1,2,3),(22,33),(100,200,300,400))
print(tuple1[0][1])

7.tuple和list之间的区别(重点)

1.元组中的元素是无法修改的【在项目中如果使用多线程环境,更多的倾向于操作不变的数据】

v1 = (11,22,33)
v1[0] = 666
TypeError: 'tuple' object does not support item assignment

2.元组在占用空间和创建时间上相对而言优于列表

import sys
l = [1,3,4,5,6,7,8,9,20]
t = (1,3,4,5,6,7,8,9,20)
print(sys.getsizeof(l),sys.getsizeof(t))

import timeit
print(timeit.timeit(stmt="[1,3,4,5,6,7,8,9,20]"),timeit.timeit(stmt="(1,3,4,5,6,7,8,9,20)"))

字典(详细)

1.概述

思考问题:存储多个学生的成绩

一种存储数据的数据结构,但是字典的无序的【在内存中元素的顺序和存放的顺序不一定相同】

字典采用的键-值【key-value】的形式存储数据

优点:具有极快的查找速度,根据hash函数映射到指定位置!!!

key --散列函数--> hash值,存储到指定地址,做到快速寻址

2.key的特点

a.字典中的key是唯一的

b.key必须是不可变的实体

​ 例如:字符串,整数,元组都是不可变的

​ list可变的,不能作为字典中的key

dictA = {(1,2,3):"five",(1,2,3):6}
dictB = {[1,2,3]:"five",(1,2,3):6}
error: TypeError: unhashable type: 'list'

3.字典的创建

语法:字典名 = {键1:值1,键2:值2,键3:值3…}

4.元素访问

#存储多个学生的成绩
dict1 = {"jack":78,"hanmeimei":99,"lilei":60}
print(dict1)

#元素访问
#1.获取 语法:字典名[key]
print(dict1["hanmeimei"])
#print(dict1["tom"]) #KeyError: 'tom'

#2.字典名.get()
result = dict1.get("lilei")
print(result)

#添加:当指定的键不存在的时候,则表示添加
dict1["tom"]  = 70
print(dict1)
#但是,如果键已经存在,则表示修改value
dict1["jack"]  = 50
print(dict1)

#删除 pop
#注意:通过键,直接删除整个键值对
dict1.pop("jack")
print(dict1)

#遍历
dict2 = {"jack":78,"hanmeimei":99,"lilei":60}

#方式一:只获取键
for key in dict2:
value = dict2[key]
print(key,value)

#方式二:只获取值
#values,得到的结果是一个列表,当做列表处理
print(dict2.values())

for value in dict2.values():
print(value)


#方式三:同时获取键和值
#items,得到的结果是一个列表,列表中的元素是元组
print(dict2.items())  #[('jack', 78), ('hanmeimei', 99), ('lilei', 60)]

for key,value  in dict2.items():
print(key,value)

#方式四
for index,key in enumerate(dict2):
value = dict2[key]
print(index,key,value)

#获取键值对
print(len(dict1))

5.案例

1. 统计每个字符在列表中出现次数
l = [1,2,3,4,5,6,7,8,9,2,2,2]
dict = {}
for item in l:
if item in dict:
  dict[item] += 1
else:
  dict[item] = 1
警惕: 避免bool&数值同时出现在字典的key中

字典的键可以使用布尔类型的,True 默认代表 1False 默认代表 0,如果包含 01 就无法使用布尔类型:
test = {0:"1", 1:"2", True:"3", False:"4"}
print(test)
{0: '4', 1: '3'}

选择题:
	A: {0: '4', 1: '3'}
	B: {True: '4', False: '3'}
	C: {0:"1", 1:"2", True:"3", False:"4"}
	D: {0:"1", 1:"2"}

没有 01 的情况下:
test = {"a":"1", "b" :"2", True:"3", False:"4"}
print(test)
{'a': '1', True: '3', 'b': '2', False: '4'}

集合

1.概述

一个无序不重复元素的序列

1. 全集: 所有元素的集合.例如实数集,所有实数组成的集合就是全集
2. 子集subset和超集superset: 一个集合A所有的元素都在另一个集合B内,A是B的子集,B是A的超集
3. 真子集和真超集: A是B的子集,且A不等于B,A就是B的真子集,B是A的真超集
4. 并集: 多个集合合并的解构
5. 交集: 多个集合的公共部分
6. 差集: 集合中除去和其他集合公共部分

2.集合创建

  1. s = {1,2,3,4,5,6,7,8,9,10}

  2. l = [1,2,3,4,5,6,7,8,9,10]

s = set(l)

注意: 空集合创建只能set(),而不是{},为啥呢?思考一下哈~~

3.集合操作

# set可以进行集合运算
a = set('abk')
b = set('bal')
print(a)
print(a - b)     # a和b的差集
print(a | b)     # a和b的并集
print(a & b)     # a和b的交集
print(a ^ b)     # a和b中不同时存在的元素

4.案例

a = [1, 2, 3, 43, 31, 2]          # 新建一个列表
b = set(a)                         # 将列表转为集合
print(b)                           # {1,2,3,43,31}

常见转换函数

函数描述
int(x [,base])将x转换为一个整数
float(x)将x转换到一个浮点数
complex(x [,y])将 x 和 y 转换到一个复数,实数部分为 x,虚数部分为 y。x 和 y 是数字表达式。
str(x)将对象 x 转换为字符串
eval(str)用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s)将序列 s 转换为一个元组
list(s)将序列 s 转换为一个列表
set(s)转换为可变集合
dict(d)创建一个字典。d 必须是一个序列 (key,value)元组。
bool转换为bool值
已标记关键词 清除标记
相关推荐
©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页