python从入门到入坑，变量，常量，数据类型(一)

第一章 python使用入门

1.1 变量基本认知

1.1.1 什么是变量

可以改变的量是变量，实际指代一段内存空间

1.1.2 为什么要有变量

为了让计算机能够像人一样去记忆事务的某种状态并

1.1.3 变量的声明

PS：变量与赋值之间加空格，不加报错

1#第一种
a = 1
b = 2
print(a)
print(b)

2#第二种
a,b = 10,20
print(a,b)

3#第三种
a = b = 100
print (a,b)

1.1.4 变量命名规则

字母数字下划线，首字符不能为数字
严格区分大小写，且不能使用关键字
变量命名有意义，且不能使用中文

查看所有系统的关键字

import keyword #import 引入keyword模块（文件）

['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class',
 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally',
 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 
'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

错误案例：

#print = 10
#print(print)
#10(10)

PS:起变量名时，要见名知意

1.1.5 变量的转换

方法一：python特有

a = 13 
b = 23
a,b = b,a
print(a,b)

方法二：通用写法

a = 13 
b = 23
tmp = a
a = b
b = tmp
print(a,b)

1.2 常量

不可改变的量：例如，身份证，血型等
约定：把所有字母变大写，代表这个值不可改

1.3 python 的数据类型

1.3.1 number 数字类型（int float bool complex）

① int 类型

intvar = 100
print(intvar)

#type 获取一个值的类型
res = type(intvar)
print(res)

#id 获取一个值的地址
res = id(intvar)
print(res)

#用二进制表示整型
intvar = 0b101
print(intvar,type(intvar),id(intvar))

#用八进制表示整型
intvar = 0o10
print(intvar,type(intvar),id(intvar))

#进制：逢几进几

#用十六进制表示整型
intvar = 0xff
print(intvar,type(intvar),id(intvar))

② float类型

###float
#表示方法1
floatvar = 3.15
print(floatvar,type(floatvar))

#表示方法2（科学计数法）
floatvar = 7.7e3
print(floatvar,type(floatvar))
floatvar = 9e-2
print(floatvar,type(floatvar))

③ bool 布尔类型 真假之类

###bool
boolvar1 = False #False代表假
boolvar2 = True #True代表真
print(boolvar1,type(boolvar1))
print(boolvar2,type(boolvar2))

④ complex 复数，高精度类型

###complex
#复数结构：实数+复数
#例：3+5j
#3:代表实数
#5j：代表虚数
#什么是j？
#如果有一个数，它的平方等于-1，那么这个数就是j，科学家认为有，表达一个高精度类型；

#方法一：
complexvar = 3+5j
complexvar1 = 5-94j
complexvar2 = 7j

print(complexvar,type(complexvar))
#方法二：
#complex(实数，虚数)
res = complex(3,4)
res2 = complex(5,-90)
res1 = complex(0,5)

print(res2)

1.3.2 str 字符串类型

###str
#两边引号引起来就叫字符串
#（1）单引号 原样是输出
strvar = '好看的皮囊千篇一律'
print(strvar)

#（2）双引号 转义输出
#转义字符——1 把有意义的字符变的无意义（2）把无意义的字符变得有意义
#语法：\ + 字符 
#\n     ——换行
#\r\n   ——换行
#\t     ——缩进（相当于tab建）
#\r     ——只输出当行的内容\r后的内容并放到最前面
#①把无意义的字符变得有意义
strvar = "有趣的灵魂200多斤"
print(strvar)
strvar = "有趣的灵魂\n200多斤"
print(strvar)
strvar = "有趣的灵魂\t200多斤"
print(strvar)
strvar = "有趣的灵魂\r200多斤"
print(strvar)
strvar = "有趣的\n灵魂\r200多斤"
print(strvar)
#②把有意义的字符变的无意义
strvar = "有趣的\"灵魂\"多斤"
print(strvar,type(strvar))

#（3）三引号 ‘’‘ 或 “”“ 支持跨行
strvar = """你喜欢我哪一点，
我喜欢你离我远一点"""
print(strvar,type(strvar))

#（4）元字符 r"字符串" 即不转义字符原型化输出
path = "E:\python35\nat"
print(path)#换行输出，转义
path = r"E:\python35\nat"
print(path)#不换行输出，不转义

#（5）格式化字符串
#%d 整型占位符
#%f 浮点占位符
#%s 字符串占位符
#格式化语法
#“字符串” % （值1，值2，...）
#%d 整型占位符
strvar = "oldgirl买了%d个lv的包包" % (5)
print(strvar)
#%2d 占2位,不够两位拿空格补位，原字符串居右
strvar = "oldgirl买了%2d个lv的包包" % (5)
print(strvar)
#%-2d 占2位,不够两位拿空格补位，原字符串居左
strvar = "oldgirl买了%-2d个lv的包包" % (5)
print(strvar)
#%s 字符串占位符
strvar = "%s" % ("今天天气很热")
print(strvar)
#综合案例
strvar = "oldgirl买了%-2d个lv的包包，花了%.2f元，心情%s" % (5,100000.213,"非常爽，反正不是花自己的钱")
print(strvar)

1.3.3 list 列表类型

###列表
#可获取，可修改，有序
#.创建一个空列表 []
listvar = []
print(listvar,type(listvar))

#2.定义一个普通列表
listvar = [100,3.45,6-90j,"abc"]
print(listvar,type(listvar))

#3获取列表里面的数据
##通过索引号，获取元素




= 9.8
print(listvar)

1.3.4 tuple 元组类型

###元组 
#可获取，不可修改，有序
#1.创建一个元组()
tuplevar = ()
print(tuple,type(tuplevar))

#2.定义一个普通的元组
#           0   1      2          3           正向索引
tuplevar = (1,"abc","oldgirl","littlegirl")
#           4   3      2           1          逆向索引
print(tuplevar,type(tuplevar))

#3.获取元组中的值
res = tuplevar[2]
print(res)

#4.修改元组中的值 ——不能修改
#tuplevar[2] = "littlegirl"  #error

#5. 有陷阱 
#逗号是区分是否是元组标识，空元组例外【元组也可不加”（）“括号】
tuplevar = (1)
print(tuplevar,type(tuplevar))

tuplevar = ("abc")
print(tuplevar,type(tuplevar))


tuplevar = (3+4j,)
print(tuplevar,type(tuplevar))

1.3.5 set 集合类型

###set 集合类型（交叉并补）
#无序（即不能修改，不支持单个查看）、自动去重、
#(1) 定义一个普通的集合
setvar = {"shy","肉鸡","gala","小虎队","赵奕欢"}
print(setvar,type(setvar))
setvar = {"shy","肉鸡","gala","小虎队","赵奕欢","赵奕欢"}
print(setvar,type(setvar))

#不可以获取其中的元素
#print(setvar[0])  #error
#不可以修改其中的元素
#setvar[0]= "i love you" #error

#（2）定义一个空集合
setvar = {}   #字典
print(setvar,type(setvar))
setvar = set()  #集合
print(setvar,type(setvar))

1.3.6 dict 字典类型

###dict
# =============================================================================
# 键值对存储的数据，可获取，有修改
# 表面上有序，实际上存储时无序
# 语法：
# {键1：值1,键2：值2,键3：值3,...}
# 早在python3.5之前 完全无序
# 在pyhon3.5之后    表面上有序，存储时无序
# =============================================================================
##（1）定义一个空的字典
dictvar = {}
print(dictvar,type(dictvar))

##(2)定义一个普通字典
dictvar = {"top":"shy","middle":"肉鸡","bottom":"gala","support":"小明","jungle":"wei"}
print(dictvar)

#获取字典中的数据
res = dictvar["support"]
print(res)
res = dictvar["middle"]
print(res)

#修改字典中的数据
dictvar["bottom"] = "jack"
print(dictvar)

set 和 dict 的数据类型限制

#字典的键 和 集合的值 都有数据类型限制
#只能使用如下类型：（不可变的数据类型 可哈希的数据类型）
#Number(int float bool complex) ,str,tuple
#可变数据：set dict list
#PS:字典的键是唯一的，字典的值没有数据类型的限制

# 字典
dictvar = {1:1 , "222":2 , 3.14:4 , 5-90j:5  , False:999 , (1,2,3,4,5):[1,2,4] }
print(dictvar , type(dictvar))
# 集合
setvar  = {1,3.4,"sd",(1,2,3),4-10j,False }
print(setvar , type(setvar))

1.4 .数据类型

1.4.1数据类型的判断

所有类型

Number => int float complex bool
容器   => str list tuple set dict

类型1

isinstance(数据,类型）

isinstance(数据,类型) => 如果是这个类型返回True , 否则返回False

lst = [1,2,3]
res = isinstance(lst,list)
print(res)

tup = 1, 
print(isinstance(tup,tuple))

#返回True 表示判断是list正确

类型2

isinstance(数据,(类型1,类型2,类型3.... ) )

—— 如果有一个类型符合括号里面的条件即为真,反之为假

res = isinstance("abc" , (str , list ,tuple) )
res = isinstance("abc" , (set , list ,tuple) )
print(res)
#返回False 表示没有符合的类型

1.4.2 变量的缓存机制

—— [仅对python3.6版本负责]

同一文件

1.对于整型而言，-5~正无穷范围内的相同值 id一致

a = 100
b = 100
a = -6
b = -6
res1 = id(a)
res2 = id(b)
print(res1 , res2)

2.对于浮点数而言，非负数范围内的相同值 id一致

a = -2.5
b = -2.5
res1 = id(a)
res2 = id(b)
print(res1 , res2)

3.布尔值而言,值相同情况下，id一致

a = True
b = False
res1 = id(a)
res2 = id(b)
print(res1 , res2)

4.复数在 实数+虚数 这样的结构中永不相同(只有虚数的情况例外)

a = 3-4j
b = 3-4j
a = 10j
b = 10j
res1 = id(a)
res2 = id(b)
print(res1 , res2)

-->容器类型部分

5.字符串 和 空元组 相同的情况下，地址相同

a = "你"
b = "你"
a = ()
b = ()
res1 = id(a)
res2 = id(b)
print(res1 , res2)

6.列表，元组，字典，集合无论什么情况 id标识都不同 [空元组例外]

a = {"a":1}
b = {"a":1}
a = (1,2)
b = (1,2)
res1 = id(a)
res2 = id(b)
print(res1 , res2)

不同文件 （了解）

小数据池 ： 针对于不同文件，提前在-5~256这个范围内，把数据驻留在内存中，供以后使用；

意义：

无论是变量缓存机制还是小数据池的驻留机制,都是为了节省内存空间,提升代码效率

1.4.3 强制类型转换

Number (int float complex bool)

var1 = 100
var2 = 3.9
var3 = True
var4 = 4-90j
var5 = "123"
var6 = "123abc"

int 强制转换为整型

"""int float bool 纯数字字符串"""
res = int(var2) # 3
res = int(var3) # True => 1 False => 0
res = int(var4) # error
res = int(var5) # 123
res = int(var6) error
print(res , type(res))

float 强制转换为浮点型

"""int float bool 纯数字字符串"""
res = float(var1)# 100.0
res = float(var3) # False => 0.0 True => 1.0
res = float(var4) error
res = float(var5) # 123.0
print(res , type(res)) 

complex 强制转换为复数

"""int float bool 纯数字字符串 complex"""
res = complex(var1)
res = complex(var3) # False => 0j True => 1+0j
res = complex(var5) # 123+0j
print(res , type(res)) 

bool 强制转换为布尔型

"""bool类型可以转换一切数据"""
res = bool(var6) # True
res = bool(var4) # True

1.4.3.1布尔类型为假的十种情况 （重中之重）

""" 0 , 0.0 , 0j , False , '' , [] , (),{},set() , None """
res = bool(0)
res = bool(0.0)
res = bool(False)
res = bool(0j)
res = bool('')
res = bool([])
res = bool(())
res = bool({})
res = bool(set())
res = bool(None)
print(res)

None 代表空的，什么也没有，一般用作变量的初始化

a = None
b = None

1.4.4 Number的自动类型转换

#int float cpmplex bool
#精度上从小到大的顺序
#默认在系统自动转换的时候，低精度向高精度转换
#bool=>int=>float=>complex

##bool + int
res = True + 15
print(res)  #16

#bool+float
res = True + 3.8 #4.8
print(res) 

#bool+complex
res = True + 1 -90j #2-90j
print(res) 

#int + float
res = 2 + 3.2 #5.2
print(res) 

#int + complex
res = 2 + 3-90j #5-90j
print(res) 

#float + complex
res = 2.1 +3-90j #5.1-90j
print(res) 

1.4.5 容器类型的强制转换

# ### 容器类型的强制转换
""" str list tuple set dict  """
"""bool , str 可以转换所有的数据类型"""
var1 = "我爱你,就像老鼠爱大米"
var2 = ["张永建","徐汇","张士宇"]
var3 = ("张永建","徐汇","张士宇")
var4 = {"张永建","徐汇","张士宇"}
var5 = {"风流倜傥,英俊潇洒,放荡不羁":"张永建","水性杨花":"徐汇","正义凛然,方方正正":"张士宇"}
var6 = 12345

# 1.强制转换成 str
"""可以转换所有的数据类型,就是单纯在原数据类型的两边套上引号就是字符串"""
res = str(var6)
# res = str(var5)
# repr => 元字符串 r"e:sdf\sdf" 不转移,原型化输出,显示引号
res = repr(res)
print(res , type(res))

# 2.强制转换成 list
"""
	如果是字符串,把字符串中的每个元素拿出来,作为列表的新元素
	如果是字典,保留所有字典的键
	如果是其他数据,就是单纯的在原数据类型的两边换上中括号[]
"""
lst = list(var1)
lst = list(var3)
lst = list(var5)
print(lst , type(lst))

# 3.强制转换成 tuple
"""
	如果是字符串,把字符串中的每个元素拿出来,作为元组的新元素
	如果是字典,保留所有字典的键
	如果是其他数据,就是单纯的在原数据类型的两边换上圆括号()
"""
tup = tuple(var5)
print(tup , type(tup))

# 4.强制转换成 set
"""
	如果是字符串,把字符串中的每个元素拿出来,作为集合的新元素[无序,自动去重]
	如果是字典,保留所有字典的键
	如果是其他数据,就是单纯的在原数据类型的两边换上花括号{}
"""
setvar = set(var1)
setvar = set(var2)
setvar = set(var5)
print(setvar , type(setvar))


# 括号里面不写数据,默认返回一个假值;
# float complex() bool() str() list() tuple() set() dict()
res = dict() 
print(res)

### 二级容器 列表list 元组tuple 集合set 字典dict

#二级列表
listvar = [1,2,3,[4,5,6]]

#二级元组
tuplevar = {1,2,3,(4,5)}

#二级集合
setvar = {'a','b','1,23'}

#二级字典
dictvar = {"a":1,"b":{"c":3}}

#四级容器
container = [1,2,3,4,(5,6,7,8,{"a":1,"b":2,"c":[1,2,"binggo"]})]
#如何获取binggo字符串——剥洋葱，一级一级剥开;多级一样剥开
res = container[-1]
print(res)  #(5, 6, 7, 8, {'a': 1, 'b': 2, 'c': [1, 2, 'binggo']})

res2 = res[-1]
print(res2) #{'a': 1, 'b': 2, 'c': [1, 2, 'binggo']}

res3 = res2["c"]
print(res3)    #[1, 2, 'binggo']

res4 = res3[-1]
print(res4)    #binggo

#简化代码

res = container[-1][-1]["c"][-1]
print(res)   #binggo


#登长的二级容器
#里面的元素是容器，并且容器里面的元素个数相同就是等长的

container = [{1,4,43},{11,3,10}]

###dict字典强转
#①需要等长的二级容器，并且容器里面的元素个数得是两个
#②外边可以是列表，元组，集合；里面可以是列表，元组
#③集合无序，所以里面不能为集合，强转会不符合愿意
#1外层是列表，内层是列表/元组
container = [["a",1],("b",2)]
dictvar = dict(container)
print(dictvar)
#2外边是元组，内层是列表，元组
container = (["c",1],("d",4))
dictvar = dict(container)
print(dictvar)
#3外面是集合，里面是元组
container = {("s",1),("d",5)}
dictvar = dict(container)
print(dictvar)

#例外情况
#1.集合无序，导致强转不符合原意
container = [{"a",1},{"b",3}]
dictvar = dict(container)
print(dictvar)   #输出结果键和键值不是我们想要的

#字符串的长度必须是2位，有极大局限性（不推荐）
container = (["a",1],"c3)
dictvar = dict(container)
print(dictvar)  #error
container = (["a",1],"c333)
dictvar = dict(container)
print(dictvar)   #error
dic = dict(container)
print(dic,type(dic)) #此处解释器无法解释