布尔值+系统功能+tuple元组+字典dict

最新推荐文章于 2021-01-17 12:09:02 发布

爱讲笑话的霸王龙

最新推荐文章于 2021-01-17 12:09:02 发布

阅读量221

点赞数 1

分类专栏： python基础

本文链接：https://blog.csdn.net/herogxw4/article/details/88778751

版权

python基础专栏收录该内容

17 篇文章 0 订阅

订阅专栏

一布尔值

只有两个值：True和False

使用场景：用于if语句和while语句中

代码演示：
#直接定义变量
b1 = True
b2 = False
print(b1,b2) 

#结合关系运算符或者逻辑运算符使用
print(4 > 5)  #False
print(1 and 0)  #False

2.空值

Python中一种特殊的数据类型，使用None表示，表示一个引用没有具体的指向

区别与0：0是数字类型，None本身是一种数据类型

代码演示：
n = 10
n = None

二、数字类型Number

1.分类

1>整数【int】，浮点数【float】，复数

代码演示：

#1.数字是属于不可变数字类型的
num1 = 10
num2 = num1
print(num1,num2)
print(id(num1) == id(num2))
print(num1 is num2)
print(num1 == num2)

"""
结论：
==：内容
is:地址

两个变量的地址相同，则内容肯定相同
两个变量的内容相同，则地址不一定相同
"""

#2.可以连续定义多个变量，使用=相连
#特点：同时定义的多个变量拥有同一个初始值
num2 = num3 = num4 = 20
"""
num4= 20
num3 = num4
num2 = num3
"""

#3.同时定义多个变量，初始值不同，使用逗号将不同的变量隔开
n1,n2 = 10,20
print(n1,n2)

#4.交换两个变量的值
#方式一：赋值交换
a = 10
b = 20
print(a,b)
a,b = b,a
print(a,b)

print("***********")

#方式二：定义中间变量
a = 10
b = 20
temp = 0
temp = a
a = b
b = temp
print(a,b)

print("***********")

#方式三：加减运算符
a = 10
b = 20

a = a + b   #a = 10 + 20
b = a - b   #b = 10 + 20 - 20
a = a - b   #a = 10 + 20 - 10
print(a,b)

print("***********")

#方式四：异或运算符（^）
#依据：一个数异或另外一个数两次，结果为该数本身
a = 10
b = 20

a = a ^ b  #a = 10 ^ 20
b = a ^ b  #a ^ b ^ b  = a
a = a ^ b  #a ^ b ^ a  = b
print(a,b)

#面试题：不借助于第三方变量，交换两个变量的值  【一，三，四】
#实际开发中，最常用一，其次是二

2>浮点数：

注意：浮点数在计算的过程中可能会出现四舍五入

3>复数

实部和虚部

表示形式：a + bj 或者complex(a,b)

注意：复数中的实部和虚部都是浮点型

2.类型转换

int()

float()

代码演示：

print(int(1.9))
print(float(1))
print(int("123"))
print(float("12.3"))


#+和-只有出现在字符串最前面的时候，可以被识别成正负号
print(int("+123"))
#print(int("1+23"))  #ValueError: invalid literal for int() with base 10: '1+23'


print(int("abc123"))

3.系统功能

3.1数学功能

方式一：功能名(xx)

方式二：需要导入模块math，math.功能名(xx)

代码演示：

#一
#1.绝对值：abs()
a1 = -10
a2 = abs(a1)
print(a2)

#2.比较两个数的大小
b1 = 10
b2 = 20
if b1 > b2:
    print(b1)
else:
    print(b2)

#(x > y) - (x < y) :比较大小，如果x < y,则返回-1，如果x > y ,则返回1
result = (b1 < b2) - (b1 > b2)
print(result)

#注意：Python中的布尔值可以进行运算，True是1，False是0
print(True - False)
#布尔类型的数据可以和数字类型的数据进行运算
print(True + 6)

#max()
print(max(23,100))
#print(max([23,100]))


#min()
print(min(23,100))

#3.求x 的y次方【求幂】 pow
#**
print(3 ** 5)
print(pow(3,5))


#4.求四舍五入  round
#默认情况下取四舍五入之后的整数
print(round(3.456))
print(round(3.656))
#可以保留小数点后多少位
print(round(3.456,2))
print(round(3.656,2))
print("%.2f" % (3.656))

import  math

#1.向上取整：ceil()
print(math.ceil(18.1))
print(math.ceil(18.9))

#2.向下取整:floor()
print(math.floor(18.1))
print(math.floor(18.9))

#3.求平方根
#注意：和数学上进行区分，开跟之后得到的为正数，为浮点数
print(math.sqrt(9))

3.2随机数功能

代码演示：

import  random


#1.random.choice(列表) ：从指定列表中随机选择一个元素出来
#指定列表
num1 = random.choice([3.4,5,5,46])
print(num1)

#列表生成器
#注意：step只能是整型，只能生成整型随机数
num2 = random.choice(range(100))
print(num2)

#使用字符串:相当于使用元素为字母的可迭代实体
num3 = random.choice("hello")   #('h','e','l','l','o')
print(num3)

#需求：产生一个4~10之间的随机数
print([4,5,6,7,8,9,10])
print(random.choice(range(4,11)))

#2.random.randint()
"""
random.randint(10,100)获取10~100之间的所有的整数随机数，但是，同时包含10和100
"""
print(random.choice(range(10,100))) #10~99
print(random.randint(10,100))

#3.random.randrange(start,end,step)
#说明：实际上和range的用法相同
#需求：产生一个100~1000之间的整数随机数
print(random.choice(range(100,1001)))
print(random.randint(100,1000))
print(random.randrange(100,1001))


#需求：从1~100之间选取一个奇数随机数
print(random.choice(range(1,100,2)))
print(random.randrange(1,100,2))

#4.random.random() 获取0~1之间的随机数，结果为浮点型
n = random.random()
print("%.2f" % (n))
print(round(n,2))

#需求：获取4~10之间的所有数的随机数【整型和浮点型】

"""
random()   0~1
[0,1] * 6 ----->[0,6]
[0,6] + 4 ---->[4,10]
"""
n = random.random() * 6 + 4
print(n)

#【了解】
#1.random.shuffle(列表) 随机排序
list2 = [2,33,5,4,5]
random.shuffle(list2)
print(list2)

#2.random.uniform(n,m) ,m > n 获取是是n~m之间的随机数，包括浮点型,类似于random.random()
print(random.uniform(4,10))

三、tuple元组

1.概述

和列表相似，本质上一种有序的集合

元素和列表的不同之处：

a.列表:[] 元组:()

b.列表中的元素可以进行增加和删除的操作，但是，一个元组一旦被定义好之后，其中的元素将不能进行任何的改变

2.创建元组

创建列表：

创建空列表：list1 = []

创建非空列表：list2 = [元素1，元素2.。。。]

创建元组

创建空元组：tuple1 = ()

创建非空元组：tuple2 = (元素1，元素2.。。。)

注意：命名的时候，列表名和元组名尽量不要使用list或者tuple

代码演示：
#1.创建空元组
t1 = ()
print(t1)

#2.创建非空元组
t2 = (2,43,5,46)
print(t2)

#3.元组中存储重复数据
#有序的
t3 = (2,3,2,3,4,55)
print(t3)

#4.存储不同类型的数据
t4 = (2,True,"abc")
print(t4)
print(type(t4))

#5.特殊情况:当定义元组的时候，如果只有一个元素，则为了和基本数据类型进行区分，需要在元素的后面添加一个逗号，表示该变量是一个元组
"""
t5 = (120)
print(t5)
print(type(t5))   #int
"""
t5 = (120,)
print(t5)
print(type(t5))

3.元组元素的访问

语法：元组名[索引]

获取元素值

修改元素值

代码演示：

#1.获取
tuple1 = (23,53,5,4,6)
print(tuple1[3])

#print(tuple1[5])  索引越界

print(tuple1[-1])

#2.修改
tuple2 = (23,53,5,4,6)
print(tuple2[1])
#注意：元组的元素不能进行随意的更改
#tuple2[1] = 100
#print(tuple2[1])  #TypeError: 'tuple' object does not support item assignment

#特殊情况
#元组和列表类似，其中存储的是变量【引用】，本质上存储的是地址，在元组的操作中，只要地址不发生改变，则认为元素没有被修改
list1 = [5,65,6,5]
tuple3 = (34,True,"abc",list1)
print(tuple3[3][1])
tuple3[3][1] = 100
print(tuple3[3][1])

#3.删除元组
tuple4 = (34,6,46)
del tuple4

4.元组的操作

代码演示：

#1.元组组合
t1 = (23,5,4,5)
t2 = (34,46,6)
print(t1 + t2)

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


#3.判断元组在不在元组中
#一般结合if语句使用
print(23 in t1)
print(100 not in t1)

#4.切片
t3 = (11,22,33,44,55,66,77,88)
print(t3[::-1])
print(t3[1:4])
print(t3[1:6:2])
print(t3[-5::-1])

5.元组功能

代码演示：

#1.获取元组的长度：len
t1 = (345,4,5)
print(len(t1))


#2.获取元组中的最大值和最小值
print(max(t1))
print(min(t1))

#list = [23,45]

#3.列表和元组之间进行相互转换,类似int()  float()  str()
#3.1元组-------》列表    list()
tuple1 = (54,64,6,56)
list1 = list(tuple1)
print(type(tuple1))
print(type(list1))


#3.2列表-------》元组  tuple()
list2 = [34,5,46,5]
tuple2 = tuple(list2)
print(type(tuple2))
print(type(list2))

#4.遍历元组
#4.1直接遍历元素
for ele1 in tuple1:
    print(ele1)

#4.2遍历索引
for i in range(len(tuple1)):
    print(i,tuple1[i])

#4.3同时遍历索引和元素
for i,element in enumerate(tuple1):
    print(i,element)

6.二维元组

代码演示：

#5.二维元组
tuple3 = ((23,344),(34,65,6,57),(56,76,7,67,686))
print(tuple3[1][1])

#遍历二维元组
#遍历外层元组
for element1 in tuple3:
    for element2 in element1:
        print(element2)

字典dict

1.概述

思考问题：存储5个人的年龄

list1 = [23,5,54,5,4] tuple1 = (23,5,54,5,4)

问题：数据容易发生混乱，对不上号

解决方案：字典，将人的姓名作为key，年龄作为value进行存储，方便查找

本质：也是一种存储数据的数据结构，但是字典是无序的，，其中存储的是键值对【key-value】

类似于list或者tuple。只是字典中存储的是多对键值对

优点：具有极快的查找速度

2.key的特性

a.字典中的key是唯一的

b.key必须是不可变实体

list是可变的，不能充当key

tuple是不可变的，可以充当key，数字，字符串，布尔型

c.通过key获取value

3.字典的创建

{}

语法：字典名 = {key1:value1,key2:value2…}

4.键值对的访问

语法：字典名[key]

代码演示：

dict1 = {"zhangsan":10,"lisi":18,"jack":20,"tom":30,"bob":34}

#1.获取
#通过key获取value,value = 字典[key]
age = dict1["lisi"]
print(age)

#通过字典[key]的方式获取value，如果key不存在，则报错
#print(dict1["xiaoming"])  #KeyError: 'xiaoming'

#get():字典.get(key)
result1 = dict1.get("lisi")
print(result1)

result2 = dict1.get("xiaoming")
print(result2)
if result2:
    print("存在的")
else:
    print("不存在的")

if result2 == None:
    print("不存在~~~")
else:
    print("存在~~~~")

#2.添加或者修改
#注意：字典是可变的，可以修改value
print(dict1)
#2.1如果key存在，则表示修改【覆盖】
dict1["jack"] = 66
print(dict1)
#2.2如果key不存在，则表示添加【添加一对键值对】
dict1["xiaoming "] = 43
print(dict1)


#3.删除：pop()
#注意：通过key删除一对键值对
dict1.pop("jack")
print(dict1)

5.字典的遍历

代码演示：

dict1 = {"zhangsan":10,"lisi":10,"jack":20,"tom":30,"bob":34}

#1.只获取key
#方式一
for key in dict1:
    print(key,dict1[key])

r0 = dict1.keys()
print(r0)
print(type(r0))

#方式二
for key in dict1.keys():
    print(key, dict1[key])

#2.只获取value
for value in dict1.values():
    print(value)


#3.同时获取编号和key
for i,key in enumerate(dict1):
    print(i,key,dict1[key])


#4.同时获取key和value
r1 = dict1.items()
print(r1)
print(type(r1))
for key,value in dict1.items():
    print(key,value)