Learn day1 基础

1.Python 简介

(1) 1989年开发的语言,创始人范罗苏姆(Guido van Rossum),别称:龟叔(Guido).

(2) python具有非常多并且强大的第三方库,使得程序开发起来得心应手.

(3) Python程序员的信仰:人生苦短,我用python!

开发方向： 机器学习人工智能 ，自动化运维&测试 ，数据分析&爬虫 ，python全栈开发

(4)  Python 版本

　　Python 2.x 版本，官方在 2020 年停止支持,原码不规范,重复较多。
　　Python 3.x 版本，功能更加强大且修复了很多bug,原码清晰,简单。

(5) 编译型与解释型语言区别

　　编译型:一次性,把所有代码编译成机器能识别的二进制码,在运行
　　代表语言:c,c++
　　优点: 执行速度块
　　缺点: 开发速度慢,调试周期长

　　解释型:代码从上到下一行一行解释并运行
　　代表语言:python,php
　　优点: 开发效率快,调试周期短
　　缺点: 执行速度相对慢

　　*linux 操作系统默认支持python语言，可直接使用

(6) Python的解释器

　　a. Cpython(官方推荐)
　　　　把python转化成c语言能识别的二进制码
　　b. Jpython
　　　　把python转化成java语言能识别的二进制码
　　c. 其他语言解释器
　　　　把python转化成其他语言能识别的二进制码
　　d. PyPy
　　　　将所有代码一次性编译成二进制码,加快执行效率(模仿编译型语言的一款python解释器)

2. 注释

(1)注释的分类

　　1. 单行注释

　　　　# 单行注释 以#号开头,右边的所有东西都被当做说明文字,程序不进行编译运行。

　　　　例子如下:
　　　　# print(‘hello world’)

   2. 多行注释

　　　　 三个单引号 或 三个双引号

   　　 例子如下:
　　　　　　'''("""）
　　　　　　　　这是第一行
　　　　　　　　这是第二行
　　　　　　'''(""")

(2)注释的注意点

　　如果外面使用三个单引号，里面使用三个双引号，反之亦然。

(3)注释的排错性

　　先注释一部分代码，然后执行另外一部分，看看是否报错，逐层缩小报错范围，找到最终错误点。

 3. 变量

(1)变量的概念

　　变量: 可以改变的量,实际具体指的是内存中的一块存储空间
　　常量: 就是不可改变的量,python当中没有明确定义常量的关键字,所以约定俗成把变量名大写就是常量,表示不可改变

(2)变量的声明
　　　　#方式1

　　　　a = 1
　　　　b = 2
　　　　print(a)
　　　　print(b)

　　　　#方式2　　　

　　　　a,b = 3,4
　　　　print(a)
　　　　print(b)

　　　　#方式3

　　　 a=b=99
　　   print(a,b)

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

(4)变量的交换
　　  #a,b = b,a

(5)不能作为变量名使用

　　# 打印python 所有关键字
　　# import 引入  keyword 模块 有一个属性kwlist 模块.属性 => 获取所有的关键字 拿来直接使用即可.

　　import keyword
　　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'
 ]
"""

　　　　# Number部分 变量的缓存机制

1.对于整型而言，-5~正无穷范围内的相同值 id一致
　　var1 = 5
　　var2 = 5
　　var1 = -6
　　var2 = -6
　　print(id(var1),id(var2))

2.对于浮点数而言，非负数范围内的相同值 id一致
　　var1 = -5.88
　　var2 = -5.88
　　print(id(var1),id(var2))

3.布尔值而言,值相同情况下，id一致
　　var1 = True
　　var2 = True
　　print(id(var1),id(var2))

4.复数在 实数+虚数 这样的结构中永不相同(只有虚数的情况例外)
　　var1 = 4+2j
　　var2 = 4+2j
　　print(id(var1) , id(var2))
　　var1 = 4j
　　var2 = 4j
　　print(id(var1),id(var2))

5.字符串 和 空元组 相同的情况下，地址相同
　　var1 = "你"
　　var2 = "你"
　　print(id(var1) ,id(var2) )

　　var1 = ()
　　var2 = ()
　　print(id(var1) ,id(var2))

6.列表，元组，字典，集合无论什么情况 id标识都不同 [空元组例外]
　　var1 = [1,2,3]
　　var2 = [1,2,3]
　　print(id(var1),id(var2))

　　# res = "我爱你" * 3
　　# print(res)

 4. Python 六大标准数据类型

(1)Number   数字类型 (int  float  bool  complex)
(2)str      字符串类型    
(3)list     列表类型      
(4)tuple    元组类型     
(5)set      集合类型     
(6)dict     字典类型      
　　　　　

4.1 数字类型 Number ( int )

　　
　　intvar = 156
　　print(intvar)

　　# type 获取变量的类型 type()
　　res = type(intvar)
　　print(res)

　　# id 或者变量所指向的这个值的内存地址
　　res = id(intvar)
　　print(res)

　　# 二进制整型 0b表示
　　intvar = 0b1010
　　print(intvar)
　　print(type(intvar))
　　print(id(intvar))

　　# 八进制整型 0o表示
　　intvar = 0o10
　　print(intvar)
　　# 获取类型
　　print(type(intvar))
　　# 获取地址
　　print(id(intvar))

　　# 十六进制 0x表示
　　intvar = 0xff
　　# 获取类型
　　print(type(intvar))
　　# 获取地址
　　print(id(intvar))

4.2 数字类型 Number ( float bool  complex)

(1) float 浮点型 就是小数

　　# 表示方法1
　　floatvar = 3.14
　　print(floatvar)
　　print( type(floatvar) )
　　print( id(floatvar) )

　　# 表示方法2 科学计数法
　　floatvar = 5.13e4 # 小数点向右移动
　　floatvar = 5.13e-2# 小数点向左移动
　　print(floatvar)

(2) bool 布尔型 ( True 真的  False 假的)

　　boolvar = True
　　boolvar = False
　　print(boolvar)
　　print(type(boolvar))
　　print(id(boolvar))

(3) complex 复数
　　"""
　　复数: 实数 + 虚数
　　比如 3+4j
　　3是实数
　　4j是虚数

　　什么是j?
　　如果有一个数,它的平方是-1,那么这个数就是j
　　科学家认为有,表达高精度类型.
　　"""

　　# 表达方式1
　　complexvar = 3-8j
　　complexvar = 5j
　　print(complexvar)
　　print(type(complexvar))
　　print(id(complexvar))


　　# 表达方式2 complex 函数,转换成复数
　　'''
　　语法:
　　complex(实数,虚数)
　　'''
　　complexvar = complex(4,2)
　　complexvar = complex(4,-2)
　　print(complexvar)

4.3 字符串类型 : 用引号引起来的就是字符串

　　"""
　　# 转义字符: 语法 \ 来进行转义
  　　 (1)把有意义的字符变得无意义
   　　(2)把无意义的字符变得有意义

　　\n => 换行
　　\r\n => 换行
　　\r => 把\r后面的字符串直接拉到当前行的行首,
　　\t => 缩进 (水平制表符) 一般一个\t 是4个空格的间距.
    
　　"""


　　1.单引号
　　　　strvar = '我爱你亲爱的菇凉,见到你我就心慌'
　　　　print(strvar)
　　　　print(type(strvar))

　　2.双引号
　　　　strvar = "黑夜给了我黑色的眼睛,但我却用它翻白眼"
　　　　strvar = "黑夜给了我黑色的眼睛,\n但我却用它翻白眼"
　　　　strvar = "黑夜给了我黑色的\n眼睛,\r但我却用它翻白眼"
　　　　strvar = "黑夜给了我黑色的\r\n眼睛,\t但我却用它翻白眼"
　　　　strvar = "黑夜给了我黑色的'眼睛',但我却用它翻白眼"
　　　　# \ 除了可以把无意义的字符变得有意义,也可以吧有意义的字符变得无意义.
　　　　print(type(strvar))

　　3.三引号 可以支持跨行操作
　　　　strvar = """轻轻的我走了,正如我轻轻的来
　　　　我轻轻的挥一挥手,不带走一片云彩
　　　　"""
　　　　strvar = '''轻轻的我走了,正如我轻轻的来　　
　　　　我轻轻的挥一挥手,不带走一片云彩
　　　　'''
　　　　print(strvar)

　　4.元字符串 r+"字符串" 让转义字符失效
　　　　strvar = r"asdfasdf\tsdfsd\n3242"
　　　　print(strvar)

　　　　strvar = r"E:\ngix相关视频"
　　　　print(strvar)

　　5.字符串的格式化

　　"""
　　%d 整型占位符
　　%f 浮点型占位符
　　%s 字符串占位符

　　语法: "字符串" % (值1,值2,.....)
　　"""
　　# %d 
　　strvar = "树则会买了%d个面膜"   %    (10)
　　print(strvar)
　　# %2d 默认数字居右
　　strvar = "郭一萌买了%2d个布加迪威龙" % (7)
　　print(strvar)
　　# %-2d 默认数字居左
　　strvar = "郭一萌买了%-2d个布加迪威龙" % (7)
　　print(strvar)


　　# %f 小数点部分自动保存6位小数
　　strvar = "黄花昨天开工资了,发了%f元" % (9.989)
　　print(strvar)
　　# %.2f 小数点保留二位 存在四舍五入
　　strvar = "黄花昨天开工资了,发了%.2f元" % (9.989)
　　print(strvar)

　　# %s 字符串占位符
　　strvar = "%s" % ("好看的皮囊千篇一律,有趣的灵魂300多斤")
　　print(strvar)

　　# 综合案例
　　strvar = "%s开工资了,发了%.2f元,昨天晚上买了%d个娃娃,心情%s" % ("王成全",99.1234,2,"感觉身体被掏空")
　　print(strvar)

4.4 容器类型数据 (列表 list 元组 tuple)

　 4.4.1 list 列表 可获取,可修改,有序

1.定义一个空列表
　　listvar = []
　　print(listvar)
　　print(type(listvar))

2.获取列表元素
　　#          0    1    2    3    4  正向索引
　　listvar = [55,3.155,True,3+9j,"abcdf"]
　　#          -5   -4  -3    -2   -1  逆向索引

　　res = listvar[2]
　　print(res)

　　# 瞬间拿到列表最后一个元素
　　res = listvar[-1]
　　print(res)

　　# 通用写法 ,用len
　　'''
　　len 可以获取容器类型数据的长度,(元素总个数)
　　'''
　　res = listvar[4]
　　print(res)
　　res = len(listvar)
　　print(res) # 5
　　#                   5       -  1 = 4
　　res = listvar[    len(listvar)-1    ]
　　print(res)

3.修改列表元素

　　listvar[0] = "银燕"
　　print(listvar)

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

  4.4.2 tuple 元组 可获取,不可修改,有序


1.定义一个空元组 *********
　　tuplevar = ()
　　print(tuplevar,type(tuplevar))
　　# 判断它是否是元组,在于,逗号 *********
　　tuplevar = ("abc",)
　　tuplevar = 1,2
　　print(tuplevar,type(tuplevar))
　　# 定义一个元组
　　tuplevar = ("李祥海","王成全","赖廷","银燕","毕杨生")


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

3.修改元组中的值? 不可以
　　# tuplevar[0] = 123 error

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

　　4.4.3 str 可获取 不可修改 有序

1.字符串可以通过索引下标取值
2.可获取
　　#          0 1 2 3 45 6 7 9  正向索引
　　strvar = "瞅你一眼,浑身哆嗦"
　　#         -9-8-7-6-5-4-3-2-1 逆向索引
　　# 获取"眼"字
　　res = strvar[3]
　　res = strvar[-6]
　　print(res)

3.可以修改么? 不可修改
　　# strvar[3] = 123 error

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

   4.4.4 集合 set (集合是用来做交叉并补操作的)

"""自动去重,无序"""

1.定义一个空集合
　　# setvar = {}  # 这个dict字典类型
　　# print(setvar,type(setvar))

　　setvar = set()
　　print(setvar,type(setvar))

　　setvar = {"刘德华","张学友","郭富城","王文"}
　　print( setvar   ,   type(setvar)   )
　　setvar = {"刘德华","张学友","郭富城","王文","王文"}
　　print(setvar)

2.集合能够获取值么? 不行
　　# res = setvar[0] error 

3.集合能够修改值么? 不行
　　# setvar[0] = 199   error
　　setvar = {1,2,"a",(1,2,3,{"a":1}) }
　　print(setvar)

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

4.5 字典dict

"""
python 3.6版本之前无序
python 3.6版本之后有序(表面上有序,本质上无序)

键值对存储的数据,有序
语法: {键1:值1 , 键2:值2 , 键3:值3 }
"""

1. 定义一个空字典
　　dictvar = {}
　　print(dictvar, type(dictvar))

　　dictvar = {"top":"夏侯惇" , "middle":"亚瑟","bottom":"鲁班七号","jungle":"刘备","support":"蔡文姬"}

2. 通过键获取字典中的值
　　res = dictvar["middle"]
　　print(res)

3. 修改字典的中的值
　　dictvar["bottom"]="孙尚香"
　　print(dictvar)

4. 字典中的键和集合中的值有要求,需要可哈希数据
　　"""
　　可哈希数据:(不可变数据) Number(int , float , bool ,complex) str , tuple 
　　可哈希数据可以作为字典的键和集合的值,剩下的都不可以

　　不可哈希数据:(可变数据) list dict set
　　字典中的键 推荐使用按照变量命名的字符串去声明最为理想;
　　"""

　　dictvar = {5:1 , 3.78:12 , True:90 , 6+8j:"abc" , "你好":99,(1,2,3):1122}
　　print(dictvar)


4.6 自动转换类型

　　# ### 自动类型转换 (Number => int bool float complex)
　　"""
　　　　精度从低->高 排行
　　　　bool -> int -> float -> complex
　　　　如果两个不同的类型进行运算,
　　　　默认低精度向高精度转化
　　"""

　　# True -> int 1 False -> int 0
　　# bool + int
　　res = True + 14
　　print(res)


　　# bool + float  # 把False 转换成浮点型0.0 在加上float
　　res = False + 4.99
　　print(res)

　　# bool + complex # 把True 转换成复数1+0j 在加上complex
　　res = True + 3+4j
　　print(res)


　　# int + float # 把int 转换成浮点型7.0 再加上float
　　res = 7 + 3.66
　　print(res)


　　# int + complex # 把int 转换成复数 3+0j 再加上complex
　　res = 3 + 9-2j
　　print(res)

　　# float + complex  把float 转化成复数6.91+0j 再加上complex
　　res = 6.91 + 11-6j
　　print(res)


4.7 Number 类型强制类型转换

　　# ### Number 部分的强制类型转换 (int float bool complex)

　　　　var1 = 23
　　　　var2 = 6.78
　　　　var3 = True
　　　　var4 = 3+2j
　　　　var5 = "1234"
　　　　var6 = "abcd121"

　　1.强制转换成int
　　　　res = int(var2)
　　　　res = int(var3)
　　　　res = int(False)
　　　　# res = int(var4) error
　　　　res = int(var5)
　　　　# res = int(var6) error
　　　　print(res , type(res))


　　2.强制转换成float
　　　　res = float(var1)
　　　　print(res)

　　　　res = float(var3)
　　　　print(res)

　　　　res = float(var5)
　　　　print(res)

　　3.强制转换成complex
　　　　res = complex(var1)
　　　　print(res)
　　　　res = complex(var2)
　　　　print(res)
　　　　res = complex(var3)
　　　　print(res)
　　　　res = complex(var5)
　　　　print(res)

　　4.强制转换成bool 要么返回True 真的 要么返回False 假的
　　　　res = bool(var4)
　　　　res = bool(var6)
　　　　res = bool(None)
　　　　print(res)

　　　　"""
　　　　　　布尔类型为假得10种情况
　　　　　　0 0.0 False 0j '' [] () set() {} None
　　　　　　None 代表空的,什么也没有,一般用在变量初始化的时候
　　　　"""
　　　　# 初始化变量的时候用
　　　　ab = None