数据类型

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.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 默认代表 1，False 默认代表 0，如果包含 0 或 1 就无法使用布尔类型：

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"}

​

没有 0 或 1 的情况下：

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.集合创建

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

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值