python初识
Posted 思江
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了python初识相关的知识，希望对你有一定的参考价值。
一、python 简介
89年开发的语言,创始人范罗苏姆(Guido van Rossum),别称:龟叔(Guido).如下图：
经典格言也是Python程序员的信仰:人生苦短,我用python!
1.2、Python特点
python具有非常多并且强大的第三方库,使得程序开发起来得心应手.
1.3、开发方向：
机器学习人工智能 ，自动化运维&测试 ，数据分析&爬虫 ，python全栈开发
二、python 版本
python 2.x 版本，官方在 2020 年停止支持,原码不规范,重复较多
python 3.x 版本，功能更加强大且修复了很多bug,原码清晰,简单
三、编译型与解释型语言区别:
3.1、编译型:一次性,把所有代码编译成机器能识别的二进制码,在运行
代表语言:c,c++
优点: 执行速度块
缺点: 开发速度慢,调试周期长
3.2、解释型:代码从上到下一行一行解释并运行
代表语言:python,php
优点: 开发效率快,调试周期短
缺点: 执行速度相对慢
*linux 操作系统默认支持python语言，可直接使用
四、python的解释器:
(1)Cpython(官方推荐)
把python转化成c语言能识别的二进制码
(2)Jpython
把python转化成java语言能识别的二进制码
(3)其他语言解释器
把python转化成其他语言能识别的二进制码
(4)PyPy
将所有代码一次性编译成二进制码,加快执行效率(模仿编译型语言的一款python解释器)
五、变量
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))
七、python运算符
| python运算符 | 注意点 | 以上是关于python初识的主要内容，如果未能解决你的问题，请参考以下文章 初识OpenGL 片段着色器(Fragment Shader)
| ------------ | --------------------------------------------------