标准数据类型
1.Number数字类型
2.列表类型 list
3.元组类型 tuple
4.字符串类型 str
5.集合类型 set
6.字典类型 dict
7.set 和 dict 的注意点
8.运算符
1.Number数字类型
# 1.int 整型 (正整型 0 负整型)
intvar = 100
print(intvar)
# type 获取值得类型
res = type(intvar)
print(res)
# id 获取值得地址
res = id(intvar)
print(res)
# 二进制整型
intvar = 0b110
print(intvar)
print( type(intvar) )
print( id(intvar) )
# 八进制整型
intvar = 0o127
print(intvar)
print(type(intvar))
print(id(intvar))
# 十六进制
intvar = 0xff
intvar = 0XFF
print(intvar)
print(type(intvar))
print(id(intvar))
"""
二进制 1 + 1 = `10
八进制 7 + 1 = 10
十六进制 f + 1 = 10
"""
# 2.float 浮点型(小数)
# 表达方式1
floatvar = 3.6
print(floatvar , type(floatvar))
# 表达方式2 科学计数法
floatvar = 5.7e5 # 小数点右移5
floatvar = 5.7e-2 # 小数点左移2
print(floatvar , type(floatvar))
# bool 布尔型 (True 真的, False 假的)
boolvar = True
boolvar = False
print(boolvar , type(boolvar))
# complex 复数类型
# 表达方式1
complexvar = 3 + 4j
print(complexvar , type(complexvar))
# 表达方法2
res = complex(3,4)
print(res , type(res))
2.列表类型 list
"""特征: 可获取,可修改,有序"""
# 1.定义一个空列表
listvar = []
print( listvar , type(listvar))
# 定义普通列表
listvar = [98,6.9,True,12-90j,"赵万里"]
# 2.获取列表中的元素
# 正向索引 0 1 2 3 4
listvar = [98,6.9,True,12-90j,"赵万里"]
# 逆向索引 -5 -4 -3 -2 -1
res = listvar[2]
res = listvar[-2]
print(res)
# 通用写法
# len 获取容器类型数据中元素个数
length = len(listvar)
res = listvar[length-1]
print(res)
# 简写
res = listvar[len(listvar)-1]
print(res)
# python逆向索引的特点,瞬间得到列表中最后一个元素
print(listvar[-1])
# 3.修改列表中的元素
listvar = [98,6.9,True,12-90j,"赵万里"]
listvar[3] = "大象"
print(listvar)
3.元组类型 tuple
"""特征: 可获取,不可修改,有序"""
# 1.定义空元组
tuplevar = ()
print(type(tuplevar))
# 2.定义一个元组
tuplevar = ("梦好心","王伟","安晓东","孙坚")
print(tuplevar , type(tuplevar))
# 获取元组中的元素
# 正向索引 0 1 2 3
tuplevar = ("梦好心","王伟","安晓东","孙坚")
# 逆向索引 -4 -3 -2 -1
print(tuplevar[2])
print(tuplevar[-1])
# 修改元组中的元素 : 元组中的值不能修改
# tuplevar[0] = "萌不好心" error
# 注意点
"""逗号才是区分是否是元组的标识符"""
tuplevar = (8.9,)
tuplevar = 8.1,
print(tuplevar)
print(type(tuplevar))
4.字符串类型 str
# 1.字符串类型
"""特征: 可获取,不可修改,有序"""
# 正向索引 0 1 2 3 4 5 6 7 8
strvar = "看你,我就心跳加速"
# 逆向索引 -9-8-7-6-5-4-3-2-1
# 获取字符串中的元素
print(strvar[3])
print(strvar[-6])
# 不能修改字符串中的元素
# strvar[3] = "你" error
# 2.字符串的格式化
"""
用引号引起来的就是字符串,单引号,双引号,三引号
# 转义字符 \ + 字符
(1) 可以将无意义的字符变得有意义
(2) 可以将有意义的字符变得无意义
\n : 换行
\r\n : 换行
\t : 缩进(水平制表符)
\r : 将\r后面的字符串拉到了当前行的行首
"""
# 字符串的格式化
"""
%d 整型占位符
%f 浮点型占位符
%s 字符串占位符
语法形式:
"字符串" % (值1,值2)
"""
# %d 整型占位符
strvar = "王同佩昨天买了%d风油精,洗澡" % (2)
print(strvar)
# %2d 占两位 (不够两位拿空格来补位) 原字符串具右
strvar = "王同佩昨天买了%2d风油精,洗澡" % (2)
print(strvar)
# %-2d 占两位 (不够两位拿空格来补位) 原字符串具左
strvar = "王同佩昨天买了%-2d风油精,洗澡" % (2)
print(strvar)
# %f 浮点型占位符
strvar = "赵世超一个月开%f工资" % (9.9)
print(strvar)
# %.2f 保留小数点后面两位小数 (存在四舍五入的情况,默认保留六位小数)
strvar = "赵世超一个月开%.2f工资" % (9.178)
print(strvar)
# %s 字符串占位符
strvar = "%s最喜欢在电影院尿尿" % ("赵万里")
print(strvar)
# 综合案例
strvar = "%s在水里%s被发现了,罚款%.2f元,并且做了%d俯卧撑." % ("孟凡伟","拉屎",500.129,50000)
print(strvar)
# 如果搞不清楚用什么占位符,可以无脑使用%s
strvar = "%s在水里%s被发现了,罚款%s元,并且做了%s俯卧撑." % ("孟凡伟","拉屎",500.129,50000)
print(strvar)
5.集合类型 set
"""特点: 无序,自动去重"""
# 1.集合无序
setvar = {"巨石强森","史泰龙","施瓦辛格","王文"}
print(setvar , type(setvar))
# 获取集合中的元素 不可以
# setvar[0] error
# 修改集合中的元素 不可以
# setvar[2] = 111 error
# 2.集合自动去重
setvar = {"巨石强森","史泰龙","施瓦辛格","王文","史泰龙","史泰龙","史泰龙"}
print(setvar , type(setvar))
# 3.定义一个空集合
setvar = set()
print(setvar , type(setvar))
6.字典类型 dict
"""
键值对存储的数据,表面上有序,本质上无序
dictvar = {键1:值1, 键2:值2 , ... }
3.6版本之前,完全无序,
3.6版本之后,存储的时候,保留了字典定义的字面顺序,在获取内存中数据时
重新按照字面顺序做了排序,所以看起来有序,实际上存储时还是无序.
"""
# 1.定义一个字典
dictvar = {"top":"the shy","middle":"肉鸡","bottom":"jacklove" ,"jungle":"臭鞋","support":"吃饱饱_嘴里种水稻"}
print(dictvar, type(dictvar))
# 2.获取字典中的值
res = dictvar["middle"]
res = dictvar["jungle"]
print(res)
# 3.修改字典中的值
dictvar["top"] = "the xboy"
print(dictvar)
# 4.定义空字典
dictvar = {}
print(dictvar, type(dictvar))
7.set 和 dict 的注意点
# ### set 和 dict 的注意点
"""
字典的键 和 集合的值 有数据类型上的要求:
(允许的类型范围)不可变的类型: Number(int float complex bool) str tuple
(不允许的类型)可变的类型 : list set dict
哈希算法的提出目的是让数据尽量均匀的在内存当中分配,以减少哈希碰撞,提升存储分配的效率;
哈希算法一定是无序的散列,所以集合 和 字典都是无序
字典的 键有要求,值没要求
字典的值可以任意换掉,但是键不可以.
"""
# 总结:
"""
无论是变量缓存机制还是小数据池的驻留机制,
都是为了节省内存空间,提升代码效率
"""
8.运算符
# ### (1)算数运算符: + - * / // % **
# +
var1 = 7
var2 = 90
res = var1 + var2
print(res)
# -
var1 = 7
var2 = 90
res = var1 - var2
print(res)
# *
var1 = 7
var2 = 10
res = var1 * var2
print(res)
# / 结果永远为小数
var1 = 10
var2 = 5
res = var1 / var2
print(res , type(res))
# // 地板除
"""被除数 ➗ 除数 = 商"""
"""注意点:如果被除数或者除数是小数,那么得到正常结果之后,数值后面带上.0变成小数"""
var1 = 10.0
var2 = 3.0
# var2 = 3.0
res = var1 // var2
print(res)
# % 取余
var1 = 7
var2 = 4
res = var1 % var2
res = -7 % 4 # -3 + 4 = 1
res = 7 % -4 # 3 + (-4) = -1
res = -7 % -4 # -3 (被除数和除数都是负的,正常结果加负号)
print(res)
# ** 幂运算
res = 2 ** 3
print(res)
# ### (2)位运算符: & | ^ << >> ~
var1 = 19
var2 = 15
# & 按位与
res = var1 & var2
"""
000 ... 10011
000 ... 01111
000 ... 00011 => 3
"""
print(res)
# | 按位或
res = var1 | var2
"""
000 ... 10011
000 ... 01111
000 ... 11111
"""
print(res)
# ^ 按位异或
"""两个值不相同=>True 反之返回False"""
res = var1 ^ var2
"""
000 ... 10011
000 ... 01111
000 ... 11100
"""
print(res)
# << 左移 (相当于乘法)
"""5乘以2的n次幂"""
res = 5 << 1 # 10
res = 5 << 2 # 20
res = 5 << 3 # 40
print(res)
"""
000 ... 101 => 5
000 .. 1010 => 10
000 ..10100 => 20
000 .101000 => 40
"""
# >> 右移 (相当于除法)
"""5地板除2的n次幂"""
res = 5 >> 1 # 2
res = 5 >> 2 # 1
res = 5 >> 3 # 0
"""
000 ... 101
000 ... 010 => 2
000 ... 001 => 1
000 ... 000 => 0
"""
print(res)
# ~ 按位非 (针对于补码进行操作,按位取反,包含每一位)
""" -(n+1) """
# res = ~22
res = ~19
print(res)
"""
原码:000 ... 10011
反码:000 ... 10011
补码:000 ... 10011
补码: 000 ... 10011
按位非: 111 ... 01100
给你补码->原码
补码:111 ... 01100
反码:100 ... 10011
原码:100 ... 10100 => -20
"""
res = ~-19
print(res)
"""
原码:100 ... 10011
反码:111 ... 01100
补码:111 ... 01101
补码: 111 ... 01101
按位非: 000 ... 10010
给你补码->原码 (因为是整数 ,原反补相同)
000 ... 10010 => 19
"""
# (3)比较运算符: > < >= <= == !=
"""比较运算符的结果要么是True , 要么是False 只有两个值"""
res = 10 > 5
res = 10 >= 10
# ==这个符号是在做比较,比较==两边的数值是否一样
res = 5 == 9
res = 5 != 9
print(res)
# (4)身份运算符 is 和 is not (检测两个数据在内存当中是否是同一个值)
# 整型 -5~正无穷
var1 = 100
var2 = 100
print(var1 is var2)
# 浮点型 非负数
var1 = -9.1
var2 = -9.1
print(var1 is var2)
# bool 相同即可
var1 = True
var2 = True
print(var1 is var2)
# complex 在实数+虚数不相同 (只有虚数的情况下例外)
var1 = 6-8j
var2 = 6-8j
var1 = -10j
var2 = -10j
print(var1 is var2)
# 容器: 相同字符串 , 空元组相同即可 剩下的所有容器都不相同
container1 = ()
container2 = ()
print(container1 is not container2)
container1 = "你"
container2 = "你"
print(container1 is not container2)
container1 = [1,23,3]
container2 = [1,23,3]
print(container1 is not container2)
# (5)成员运算符: in 和 not in (针对于容器型数据)
"""字符串判断时,必须是连续的片段"""
strvar = "今天天气要下雨,赶紧回家收衣服"
res = "今" in strvar
print(res)
# 针对于列表,元组,集合
container = {"赵沈阳","赵万里","赵世超"}
res = "赵世超1223232" not in container
print(res)
# 针对于字典 (判断的是字典的键,不是值)
container = {"zsy":"赵沈阳","zwl":"赵万里","zsc":"赵世超"}
res = "赵沈阳" in container # False
res = "zsy" in container
print(res)
# (6)逻辑运算符: and or not
# and 逻辑与
"""全真则真,一假则假"""
res = True and True # True
res = True and False # False
res = False and True # False
res = False and False # False
print(res)
# or 逻辑或
"""一真则真,全假则假"""
res = True or True # True
res = False or True # True
res = True or False # True
res = False or False # False
print(res)
# not 逻辑非
res = not True
res = not False
print(res)
# 逻辑短路
"""
无论后面的表达式是True 还是False 都已经无法改变最后的结果,那么直接短路,后面的代码不执行;
(1) True or print("程序执行了 ~ 1111")
(2) False and print("程序执行了 ~ 2222")
"""
"""
计算规律:
先脑补计算当前表达式的布尔值是True还是False
如果出现了 True or 表达式 或者 False and 表达式的情况,直接返回前者,后面代码不执行
如果没有出现短路效果,直接返回后者
"""
# 逻辑运算符的优先级
""" 优先级从高到低: () > not > and > or """
# ### (7)赋值运算符: = += -= *= /= //= %= **=
# = 赋值运算符 将右侧的值赋值给左侧变量
a = 5 <= 3
print(a)
var1 = 10
var2 = 5
# +=
"""var1 = var1 + var2"""
# var1 += var2
# print(var1)
# -=
"""var1 = var1 - var2"""
# var1 -= var2
# print(var1)
# %=
"""var1 = var1 % var2"""
var1 %= var2
print(var1)
"""
总结:
个别运算符:
运算符优先级最高的: **
运算符优先级最低的: =
()可以提升优先级
一元运算符 > 二元运算符 (优先级)
一元运算符 : 同一时间,操作一个值 ~ -
二元运算符 : 同一时间,操作一个值 + - * / ....
同一种类运算符:
算数运算符 : 乘除 > 加减
逻辑运算符 : () > not > and > or
位运算符 : ( << >> ) > & > ^ > |
整体排序:
算数运算符 > 位运算符 > 比较运算符 > 身份运算符 > 成员运算符 > 逻辑运算符
赋值运算符用来做收尾
"""
浙公网安备 33010602011771号