python基础知识-变量和数据类型
变量
变量用于存储信息,以便在计算机程序中引用和操作。它们还提供了一种用描述性名称标记数据的方法,以便读者和我们自己能够更清楚地理解我们的程序。将变量看作容纳信息的容器是有帮助的。它们的唯一目的是在内存中标记和存储数据。然后可以在整个程序中使用这些数据。
声明变量
1
2
3
|
#_*_coding:utf-8_*_ name = "lsj" |
上述代码声明了一个变量,变量名为: name,变量name的值为:"lsj"
变量定义的规则:
- 变量名只能是 字母、数字或下划线的任意组合
- 变量名的第一个字符不能是数字
- 以下关键字不能声明为变量名
['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield']
变量的赋值
1
2
3
4
5
6
7
8
|
name = "lsj" name2 = name print (name,name2) name = "Jack" print ( "What is the value of name2 now?" ) |
4.1、变量
变量:把一个值赋给一个名字时,它会存储在内存中,把这块内存称为变量,这个值是可变的。在一个页面只有重新定义内存才 释放
注意:
1.先赋值后使用
2.变量名可以包括字母、数字、下划线,不能以数字开头
3.赋值号,左边是变量名,右边是值
4.2、字符串
字符串:引号内的一切东西都是字符串,单引号(‘’)或双引号(“”)
注意:
1.引号必须成对
2.字符串内容中需要出现单引号或双引号时,用(\)进行转义或用上不同的引号字符
>>> "Let's go" "Let's go" >>> 'Let\'s go'
"Let's go"
4.3、原始字符串
原始字符串:解决反斜杠(\)与后边的字符恰好形成转义符。
注意:
无论是否原始字符串,都不能以反斜杠作为结尾(反斜杠放在字符串的末尾表示该字符串还没有结束,换行继续的意思)
>>> String="c:\\new"
>>> string='c:\\new'
>>> print(String)
c:\new
>>> print(string)
c:\new
4.3、长字符串
长字符串:解决行数非常多的问题。
使用三重引号字符串
”””内容”””
4.5、数据类型
type查看数据类型
isinstance比较两个数据类型
Python的变量是没有数据类型的,Python的变量更像是名字标签,想贴哪儿就贴哪儿,通过这个标签,就可以轻易找在内存中存放位置了。
但是Python并不是没有数据类型这回事
‘520’ 和 520
类型 |
描述 |
整数(int) |
一般意义上的数,包含八进制(以数字为0开头)及十六进制(以0x开头),如2007、-2007、07(八进制)和0xAB(十六进制)等 |
长整数(long) |
无限大小的数,在其结尾添加小写字母l或者大写字母L,如2007000000000000000L |
浮点数(float) |
小数,或者用E或e表示的幂,如2.7、1234e—+10、1.5E-10 |
整型:
Python3的整型已经与长整型进行了无缝结合。
Python3的整型类似于JAVA的BigInterger类型,它的长度不受限制,只限于计算机的虚拟内存总数
所以用Python3很容易进行大数计算
>>> a=1
>>> b=12.5
>>> a+b
13.5
>>> c=20000000000
>>> c
20000000000
>>> d=5768965847438393
>>> d-c
5768945847438393
>>> 0o7+0o5
12
>>> 0x7+0xa
17
>>> '''八进制7+八进制5使用8进制输出'''
'八进制7+八进制5使用8进制输出'
>>> print('%o'%(0o7+0o5))
14
浮点型:
就是平时我们所说的小数
E记法:用于表示特别大和特别小的数
布尔类型:
用True和False来表示“真”与“假”,也可以用1和0代表
>>> True+True
2
>>> False+False
0
>>> True+False
1
>>> True/False
Traceback (most recent call last):
File "D:\anaconda3\lib\site-packages\IPython\core\interactiveshell.py", line 3343, in run_code
exec(code_obj, self.user_global_ns, self.user_ns)
File "<ipython-input-2-f64d1295bbce>", line 1, in <module>
True/False
ZeroDivisionError: division by zero
获得关于类型的信息:
1.type()
2.isinstance()
此函数有两个参数,第一个是待确定类型的数据;第二个是指定一个数据类型。
根据两个参数返回一个布尔类型的值,True表示类型一致,False表示类型不一致
>>> type(520)
<class 'int'>
>>> isinstance(a,str)
False
>>> isinstance(520,int)
True
>>> isinstance(520,float)
False
4.6、类型转换
接下来介绍几个跟数据类型紧密相关的函数:
int()
float()
str()
变量
5.1、变量的概念: 可以改变的量就是变量。具体指代的是内存的一块空间
变量的概念
rujia_305 = "王文"
rujia_305 = "李四"
print(rujia_305)
win+R-->mspaint(画图板)
5.2、变量的声明:
# (1) 单个变量的定义
a = 1
b = 2
print(a)
print(b)
# (2) 多个变量的定义
a,b = 3,4
print(a , b)
# (3) 相同变量定义
a = b = 5
print( a , b )
5.3、变量的命名:
#字母数字下划线 ,首字符不能为数字
#严格区分大小写 ,且不能使用关键字
#变量命名有意义 ,且不能使用中文哦
_abc123 = 3
abc = 10
ABC = 20
print(abc)
# 查看系统所有的关键字
# 引入 模块
import keyword
# res => result
res = keyword.kwlist
print(res)
"""
['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']
"""
# 变量名字要有意义
my_car = "宝马"
abc = "宝马"
"""
在python中,用中文命名变量没有语法错误,但是严禁使用
utf-8 国际标准字符编码(万国码) 一个中文占用3个字节,数字或者符号占用一个字节
gbk 国标编码 一个中文占用2个字节,数字,字母,符号占用一个字节
(1) 防止乱码
(2) 占用的空间更小
"""
中文 = "兔子各个"
print(中文)
word = "兔子各个"
5.4、变量的交换:
# 变量的交换
a = 10
a = 15
print(a)
# 通用写法
tmp = a
a = b
b = tmp
print(a , b)
# python特有写法
a = 20
b = 30
a,b = b,a
print(a,b)
5.5、常量:就是不可改变的量,python当中没有明确定义常量的关键字,所以约定俗成把变量名大写就是常量,表示不可改变。
如:P = 3.1415926,SHENFENZHENG = 210202200005016688
python六大标准数据类型:
6.1、数据类型分类:
(1)Number 数字类型 ( bool int float complex)
(2)str 字符串类型
(3)list 列表类型
(4)tuple 元组类型
(5)set 集合类型
(6)dict 字典类型
6.2、Number数字类型分类:
6.2.1、int : 整数类型 ( 正整数 0 负整数 )
# ### Number
# int => 整型 (正整数 0 负整数)
intvar = 1000
print(intvar)
# type 获取类型
res = type(intvar)
print(res)
# id 获取地址
res = id(intvar)
print(res)
内存地址的命名相当于内存地址号
![](https://img2018.cnblogs.com/i-beta/1204515/202002/1204515-20200227115132208-320244971.png)
# 二进制整型
intvar = 0b101
print(intvar)
res = type(intvar)
res = id(intvar)
print(res)
# 八进制整型
intvar = 0o127
print(intvar)
# 十六进制整型
intvar = 0xff
print(intvar)
6.2.2、float: 浮点数类型 ( 1普通小数 2科学计数法表示的小数 例:a = 3e-5 #3e-05 )
# float 浮点型(小数)
# 表达方式一
floatvar = 3.14
print(floatvar)
res = type(floatvar)
print(res)
# 表达方式二 (科学计数法)
floatvar = 3.98e3 # 3.98乘以10的3次方(小数点向右移动3位) 结果:3980
floatvar = 3.98e-3 # 3.98乘以10的-3次方(小数点向左移动3位) 结果:0.00398
print(floatvar)
res = type(floatvar)
print(res)
6.2.3、bool: 布尔值类型 ( 真True 和 假False )
# bool 布尔型 (True真的 False假的) 注意:T和F是大写,小写则报错
boolvar = True
print(boolvar)
res = type(boolvar)
print(res)
6.2.4、complex: 复数类型 ( 声明复数的2种方法 ) (复数用作于科学计算中,表示高精度的数据,科学家会使用)
# complex 复数
"""
复数 : 实数 + 虚数
例如 : 3 + 5j
实数 : 3
虚数 : 5j
j : 如果有一个数,他的平方等于-1,那么这个数就是j,科学家认为有,表达的是高精度的类型,j是Python内部定义好的,记住就好。
"""
# 表达方式一
complexvar = 2-90j
complexvar = -90j
print(complexvar,"<=====>")
res = type(complexvar)
print(res)
# 表达方式二
"""
complexvar = complex(实数,虚数)
"""
complexvar = complex(3,-90)
print(complexvar , type(complexvar) )
6.3、容器类型分类:五个
字符串:str "nihao" 特点: 可获取,不可修改,有序 列表: list [1,2,3] 特点: 可获取,可修改,有序
元组: tuple (6,7,8) 特点: 可获取,不可修改,有序
集合: set {'a',1,2} 特点: 无序,自动去重
字典: dict {'a':1,'b':2} 特点:键值对存储的数据,表面上有序,实际上无序
6.3.1、字符串 str
# 字符串 str : 用引号引起来的就是字符串
"""
# 转义字符:通过\进行转换 (1) 把无意义的字符变得有意义 (2) 把有意义的字符变得无意义 \n : 换行 \r\n : 换行 \t : 缩进(水平制表符)Python标准一个缩进是4个空格 \r : 把\r后面的字符串直接拉到当前行行首
\ : 折行 """
# (1) 单引号引起来的字符串
strvar = '今天天气不错'
print(strvar , type(strvar))
# (2) 双引号引起来的字符串# 注意:Python中的单双引号是没有区别的
strvar = "大江东去浪涛尽,千古风流人物" print(strvar,type(strvar))
# 把无意义的字符变得有意义
strvar = "大江东去浪涛尽,\n千古风流\r\n人物"
strvar = "大江东去浪涛尽,\t千古风流人物"
strvar = "大江东去浪涛尽,\r千古风流人物"
strvar = "大江东去\n浪涛尽,\r千古风流人物"
print(strvar)
输出:
大江东去
千古风流人物
# 把有意义的字符变得无意义
strvar = "大江东去浪涛尽,千古'风流'人物"
strvar = '大江东去浪涛尽,千古"风流"人物'
strvar = "大江东去浪涛尽,千古\"风流\"人物"
print(strvar)
# \的折行功能,一行代码过长阅读性差
strvar = "大江东去浪涛尽,\
千古'风流'人物"
print(strvar)
输出:
大江东去浪涛尽,千古'风流'人物
# (3) 三引号引起来的字符串 (支持跨行)
strvar = '''
本来无'一'物,
何处惹"尘"埃
'''
print(strvar , type(strvar))
# (4) 元字符串 r + "字符串" => 表示不转义字符,原型化输出字符串,用在导入路径上
strvar = r"E:\python29\day3\no\ppp.py"
print(strvar)
# (5) 字符串的格式化
"""
"字符串" % (值1,值2,值3 ... )
%d => 整型占位符
%f => 浮点型占位符
%s => 字符串占位符
"""
# %d 整型占位符
strvar = "john同学今年%d岁" % (5)
print(strvar)
# %2d 占用2位空间,默认居右
strvar = "john同学今年%2d岁" % (5)
print(strvar)
# %-2d 占用2位空间,默认居左
strvar = "john同学今年%-2d岁" % (5)
print(strvar)
# %f 浮点型占位符(默认保留6位小数)
strvar = "程序员过家家这个同学今天开工资了,发了%f元" % (9.18)
print(strvar)
# %.1f 小数点后边保留1位小数 (存在四舍五入的情况)
strvar = "程序员过家家这个同学今天开工资了,发了%.1f元" % (9.18)
print(strvar)
# %s 字符串占位符
strvar = "%s" % ("这个同学真帅")
print(strvar)
# 综合案例
strvar = "%s今天开工资了,一共%.2f元,买了%d个布加迪威龙" % ("李",19.378,3)
print(strvar)
strvar = "%s今天开工资了,一共%s元,买了%s个布加迪威龙" % ("李",19.378,3)
print(strvar)
"""
特点: 可获取,不可修改,有序
"""
# 0123
strvar = "abcd"
# -4-3-2-1
# 获取a元素
res = strvar[0]
print(res)
# 可以修改字符串当中的元素么? 不行
# strvar[0] = "z" error
6.3.2、列表list
"""
特点: 可获取,可修改,有序
"""
# 定义一个空列表
listvar = []
print(listvar, type(listvar))
# (1) 定义一个普通的列表
# 正向索引下标 0 1 2 3 4
listvar = [1,3.14,False,3+4j,"你好帅哥"]
# 逆向索引下标 -5 -4 -3 -2 -1
# (2) 获取列表当中的元素
res = listvar[3]
# python特点,用下标-1
res = listvar[-1]
# 获取列表中最后一个元素(通用写法)
# len 获取容器类型数据的总长度(元素总个数)
res = len(listvar)
max_len = res - 1
print(max_len) # 4
val = listvar[max_len]
print(val)
# (3) 修改列表当中的元素
listvar[-4] = "太帅了"
print(listvar)
6.2.3、元组 tuple()
"""
特点: 可获取,不可修改,有序
"""
# 1.定义一个普通的元组
# 正向下标 0 1 2 3
tuplevar = ("a",True,9.1,123)
# 逆向下表 -4 -3 -2 -1
# 获取元组当中的数据
res = tuplevar[2]
print(res)
# 2.是否可以修改元组当中的数据? 不可以
# tuplevar[0] = "bbb"
# print(tuplevar)
# 3.元组的注意点:
# (1) 定义一个空元组
tuplevar = ()
# (2) 逗号是区分是否是元组的标识符
tuplevar = (True,)
tuplevar = True,1
print(tuplevar, type(tuplevar))
6.3.4、集合 set()
# ### 集合set (作用:交差并补)
"""
特点: 无序,自动去重
"""
# 定义一个集合
setvar = {"刘德华","郭富城","张学友","王文"}
print(setvar , type(setvar) )
# 1.集合无序
# 获取集合中的元素? 不可以
# res = setvar[0]
# print(res) error
# 修改集合中的元素? 不可以
# setvar[0] = "abc" error
# 2.自动去重
setvar = {"刘德华","郭富城","张学友","王文","王文","王文"}
print(setvar, type(setvar))
# 3.定义一个空集合
setvar = {} # 空字典
setvar = set()
print(setvar , type(setvar))
6.3.5、字典
# ### 字典dict
"""
特点:键值对存储的数据,表面上有序,实际上无序
语法: dictvar = {键1:值1,键2:值2,键3:值3 ... }
"""
# 1.定义一个字典
dictvar = {"top":"夏侯淳","middle":"安其拉","bottom":"程咬金","jungle":"李白","support":"蔡文姬"}
print(dictvar , type(dictvar))
# 2.获取字典当中值
res = dictvar["middle"]
print(res)
# 3.修改字典当中的值
dictvar["bottom"] = "后裔"
print(dictvar)
6.3.2、自动类型转换
当2个不同类型的数据进行运算的时候,默认向更高精度转换,数据类型精度从低到高: bool int float complex
# ### Number 的自动类型转换 (bool int float complex)
"""
默认按照精度从低到高进行转换
bool -> int -> float -> complex
自动类型转换规则: 将低精度向高精度自动转换
"""
# bool + int
res = True + 100
print(res,type(res))
# bool + float
res = False + 3.56 # False => 0.0
print(res,type(res))
# bool + complex
res = True + 3+4j # True => 1 + 0j
print(res)
# int + float
res = 100 + 6.8 # 100 => 100.0
print(res)
# int + complex
res = 100 + 6-7j #100 = > 100+0j
print(res)
# float + complex # 9.5 => 9.5+0j
res = 9.5 + 3+4j
print(res)
6.3.3、强制类型转换
Number部分
int : 整型 浮点型 布尔类型 纯数字字符串
float: 整型 浮点型 布尔类型 纯数字字符串
complex: 整型 浮点型 布尔类型 纯数字字符串 (复数)
bool: ( 容器类型数据 / Number类型数据 都可以 )
# Number 的强制类型转换 (int float complex bool )
var1 = 4
var2 = 6.89
var3 = 4-2j
var4 = False
var5 = "666888"
var6 = "123abc"
# 强制转换成int
res = int(var2) # 6
# res = int(var3) # error
res = int(var4) # True => 1 False => 0
res = int(var5) # 666888
# res = int(var6) # error
print(res , type(res) )
# 强制转换成float
res = float(var1) # 4.0
res = float(var4) # False => 0.0 True => 1.0
res = float(var5) # 666888.0
print(res , type(res))
# 强制转换成complex
res = complex(var1) # 4 + 0j
res = complex(var2) # 6.89 + 0j
res = complex(var4) # True => 1 + 0j False => 0j
res = complex(var5) # 666888 + 0j
# res = complex(var6) # error
print(res)
# 强制转换成bool (True False)
res = bool(None)
print(res)
# ***** bool类型为假的十种情况
"""
0 , 0.0 , 0j , False , '',[],(),set(),{} ,None
None : 关键字,代表空的,什么也没有,一般用来做初始化操作
a = None
"""
"""
int() bool() float() complex() 都可以为当前变量初始化一个默认值
"""
res = complex()
print(res)
容器类型部分
str: ( 容器类型数据 / Number类型数据 都可以 )
list: 字符串 列表 元组 集合 字典
tuple: 字符串 列表 元组 集合 字典
set: 字符串 列表 元组 集合 字典 (注意:相同的值,只会保留一份)
# ### 容器数据的强制类型转换 (list tuple set dict str)
var1 = "abc"
var2 = [1,2,3,4]
var3 = ("a","b")
var4 = {"a1","a2","a3"}
var5 = {"a100":1,"b100":2}
var6 = 90
# 强制转换成字符串 => str
"""
强制转换成字符串:就是单纯的在当前数据类型的两边套上引号;
"""
res = str(var2)
res = str(var3)
res = str(var6)
print(res , type(res) )
# repr 原型化输出字符串,可以显示引号
print(repr(res),type(res))
# 强制转换成列表 => list
"""
如果是字符串,把里面的字符作为列表的新元素,
如果是字典,只保留字典的键,忽略掉值
否则,只是单纯的在原有数据类型的两边,套上[]
"""
res = list(var1)
res = list(var3)
res = list(var4)
res = list(var5)
print(res , type(res))
# 强制转换成元组 => tuple
"""
如果是字符串,把里面的字符作为元组的新元素,
如果是字典,只保留字典的键,忽略掉值
否则,只是单纯的在原有数据类型的两边,套上()
"""
res = tuple(var1)
res = tuple(var2)
res = tuple(var5)
print(res , type(res))
# 强制转换成集合 => set
"""
如果是字符串,把里面的字符作为集合的新元素,
如果是字典,只保留字典的键,忽略掉值
否则,只是单纯的在原有数据类型的两边,套上{}
"""
res = set(var1)
res = set(var2)
res = set(var5)
print(res)
dict: 使用 二级列表,二级元组,二级集合(里面的容器数据只能是元组)
# 二级容器
# 二级列表
lst = [1,2,3,4,5,[6,7,8,9,10]]
# 二级元组
tup = (3,4,5,(6,7,8))
# 二级集合
setvar = {"a","b","c",("d","e","f")}
# 二级字典
dic = {"a":1,"b":2,"c":{"f":10,"e":15}}
res = dic["c"]["e"]
print(res)
# 四级容器
# 获取14这个元素?
container = [1,2,3,4,5,(6,7,8,{"a":1,"b":2,"c":[11,12,13,14]})]
# (6, 7, 8, {'a': 1, 'b': 2, 'c': [11, 12, 13, 14]})
res = container[-1]
print(res)
# {'a': 1, 'b': 2, 'c': [11, 12, 13, 14]}
res2 = res[-1]
print(res2)
# [11, 12, 13, 14]
res3 = res2["c"]
print(res3)
# 14
res4 = res3[-1]
print(res4)
# 简写
res = container[-1][-1]["c"][-1]
print(res)
# 等长的二级容器
"""
(1) 里面的元素都是容器
(2) 并且容器里面的元素个数都相同
"""
lst = [ (1,2,3,4) , {"a","b","c","d"} ]
lst = ([1,3,5],(7,8,9))
# ### 强制转换成字典
"""
要求: 等长的二级容器,并且里面的元素个数是2个
"""
# (1) 外面是列表,里面是等长的容器,元素个数是2个
lst = [ ["a",1] , ("b",2) , ("c",3) ]
dic = dict(lst)
print(dic , type(dic))
# (2) 外面是元组,里面是等长的容器,元素个数是2个
tup = ( ["c",1] ,("d",2) )
dic = dict(tup)
print(dic , type(dic))
# (3) 外面是集合,里面是等长的容器,元素个数是2个
setvar = {("a",10),("b",15)}
dic = dict(setvar)
print(dic, type(dic))
# (4) 例外情况,语法上正确,不推荐使用
# 情况一
"""字符串形式长度只能是2个,不能表达一个较大数据,不推荐使用"""
lst = ["a1","b2"] #"c33" error
dic = dict(lst)
print(dic)
# 情况二
"""集合无序,本意是b作为字典的键,2作为字典的值,由于无序没有达到原来的本意,不推荐使用"""
lst = [ ('a',1) , {"b",2} ]
print(dict(lst))
# 快速去掉列表当中的重复数据
lst = [11,11,"a","a","a","c","c","c","dd","dd"]
# 强制转换成集合 (去重)
setvar = set(lst)
print(setvar)
# 强转转换成列表,恢复成原来的数据类型
listvar = list(setvar)
print(listvar)
"""
str() list() tuple() set() dict() 可以为当前的数据类型创建一个默认值
"""
res = dict()
print(res)
6.3.4、字典和集合的注意点
哈希算法
定义:把不可变的任意长度值计算成固定长度的唯一值,这个值可正可负,可大可小,但长度固定该算法叫哈希算法(散列算法),这个固定长度值叫哈希值(散列值)
特点:
1.计算出来的值长度固定且该值唯一
2.该字符串是密文,且加密过程不可逆
作用:
用哈希计算得到一个字符串的用意?
例如:比对两个文件的内容是否一致?
例如:比对输入的密码和数据库存储的密码是否一致
字典的键和集合中的值都是唯一值,不可重复:
为了保证数据的唯一性,
用哈希算法加密字典的键得到一个字符串。
用哈希算法加密集合的值得到一个字符串。
如果重复,他们都是后面的替换前面的。自动去重
""" 对集合的值 和 字典的键 有数据类型上的要求 可哈希的数据类型: Number(int , bool , float ,complex) ,str , tuple 不可哈希的数据类型 list set dict
3.6版本之前都是 字典和集合都是无序的 3.6版本之后对字典做了优化,存储数据的时候用了哈希算法,但是拿出数据的时候,重新按照定义的顺序做了排序,所以看起来有序,实际上无序 记住:哈希算法是典型的无序的特征. ***推荐大家使用变量命名的字符串作为字典的键*** """ # 字典的键要求可哈希 dictvar = {3:"a",False:"b",4.56:"c",4+9j:"d","中文":"ff",(1,2,3):"zz"} print(dictvar) # 获取元素 zz res = dictvar[(1,2,3)] print(res) # 集合的值要求可哈希 setvar = {1,3.5,False,9+90j,"abc",(1,2,3)} print(setvar , type(setvar))