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)
内存地址的命名相当于内存地址号

 # 二进制整型

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))