Python ( 学习 基础篇第一部 )

目录

注释

　　注释的分类

　　注释的注意点

变量

　　变量的概念

　　变量的声明

　　变量的命名

　　变量的交换

　　变量的缓存机制

　　常量

进制

　　进制的转换

　　原码 反码 补码

六大数据类型

　　Number 的四大类

　　字符串 str

　　列表 list 

　　元祖 tuple 

　　　　集合 set 

　　　　字典 dict

　　　　占位符

类型的转换

　　Number的强制转换( int flost bool coplex ) 

　　　　Number的自动转换( int flost bool coplex ) 

　　容器类型数据的强制转换 ( str list tuple set dict ) 

　　　　二级容器与等长的二级容器( list tuple set dict )

注释

注释: 就是对代码的解释,说明,方便后期对代码的修改与阅读

注释的分类

• 单行注释: 用一个单引号或者一个双引号包括起来
• 多行注释: 用三个单引号或者三个双引号包括起来

注释的注意点

1. 多行注释可以进行换行
2. 多行注释内外的引号不可以相同
3. 利用注释具有一定的排错性

变量

变量: 可以改变的量, 实际上是内存中开辟的一块空间

变量的概念

liuun = "学峰'

变量的声明

#1
a = 100
b = 200
print(a)
print(b)

#2
a,b = 10,20
print(a,b)

#3
a = b = 400
print(a,b)

变量的命名规则

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

变量的交换

通用写法:

a = 13
b = 14
tmp = a # tmp = 13
a = b   # a = 14
b = tmp # b = 13
print( a , b ) # 14 13```

Python特有写法:

a = 12


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

变量的缓存机制

只有两个值相同,就只开辟一个空间

1. Number 部分
   对于整型而言，-5~正无穷范围内的相同值 id一致
   对于浮点数而言，非负数范围内的相同值 id一致
   布尔值而言,值相同情况下，id一致
   复数在 实数+虚数 这样的结构中永不相同(只有虚数的情况例外)
2. 容器类型部分
   字符串 和 空元组 相同的情况下，地址相同
   列表，元组，字典，集合无论什么情况 id标识都不同 [空元组例外]

常量

不变量( 约定俗称,大写格式,这个值不能改变)

进制

b = bit  位(比特)
B = Byte 字节
1KB = 1024B
1MB = 1024KB
1GB = 1024MB
1TB = 1024GB
1PB = 1024TB
1EB = 1024PB    

进制的转换

二进制:由2个数字组成,有0 和 1
0b 代表2进制

八进制:由8个数字组成,有0,1,2,3,4,5,6,7
0o 代表8进制

十进制:有10个数字组成,有0,1,2,3,4,5,6,7,8,9

十六进制:有16个数字组成,有0,1,2,3,4,5,6,7,8,9,a,b,c,d,e
0f 代表16进制

原码 反码 补码

码

原码:二进制表现的形式

反码:二进制码0 变1 ,1变 0 叫做反码,[原码][补码]之间的转换形式.(首位符号位不取反)

补码:二进制的储存形式

提出补码的原因

补码的提出用于表达一个数的正负( 为了实现计算机的减法运算操作) 

计算机默认只能做加法, 实现减法用负号: 5+(-3) => 5-3

乘法除法:是通过左移和右移 << >> 来实现

原码形式的正负关系

原码的特点:第一位是1

00000000  1  表达数字正1 

10000000  1 表达数字负

补码形式的正负关系

补码的特点: 高位都是1

00000000 1 表达数为正1 

11111111  1 表达数为负1

运算顺序

补码 > 原码 > 最后人们可以看到的数

转换规律

如果是一个正数: 原码 = 反码 = 补码
如果是一个负数: 原码 与 反码 之间 , 互为取反加1
原码 = 补码取反加1 给补码求原码
补码 = 原码取反加1 给原码求补码

转码

5
原码: 0000 ... 101
反码: 0000 ... 101
补码: 0000 ... 101

-3    (原码中,左边第一个高位,标记的是符号)
原码: 1000 ... 011
反码: 1111 ... 100
补码: 1111 ... 10

在底层用补码做运算
0000 ... 101   => 5
1111 ... 101   => -3
0000 ... 010   => 2

总结:

高位0 代表正数, 高位1 代表负数 (原码) 

计算机在运算时,用补码在运算

　　如果是正数: 补码 = 反码 = 原码

　　如果是负数: 原码 = 补码取反 +1 (原码补码, 互为取反+1)

源码是用来显示的   补码是用来存储或者运算的

六大数据类型

1.Number
2.字符串类型 str
3.列表类型 list
4. 元祖
5. 字典
6. 集合
(2.3.4.5.6.)属于容器类型数据

Number 的四大类

int 整型

intvar = 123
print(intvar)

float 浮点型

floatvar = 4.88
print(floatvar)

bool 布尔型

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

coplex 复数型

complex  实数 + 虚数
3+4j
3:  实数
4j: 虚数

字符串 str

字符串的特点:

可获取, 可修改,有序.

单引号引起来
strvar = '今天是开课的第二天的是字符串'

双引号引起来的字符串 
strvar = “文哥是这个世界上,\n我认为最帅的男人”

三引号引起来的字符串 ‘’’ “”"(支持跨行的效果)
strvar = ‘’’
我感觉我走错了房间,
貌似python31的同学是’祖安’服务器请来的"救兵"
‘’’

字符串原型化输出

#元字符串 r"字符串" 不转义字符,原型化输出字符串
strvar = r"E:\nython31\tay2"
print(strvar)

#格式次付出
#语法 : “字符串” % (值1,值2,值3)
%d 整型占位符
%f 浮点型占位符
%s 字符串占位符

列表 list 

列表的特点:

可获取, 可修改,有序

#定义一个空列表
listvar=[]


#定义一个普通的列表
listvar =        [100,19.123,True,1+12j,"马生平"]


#获取列表当中的值
listvar= [100,19.123,True,1+12j,"马生平"]
res = listvar[2]
res = listvar[-3]
print(res)


#修改列表当中的元素
listvar[-3] = False
print(listvar)

元祖 tuple 

元祖的特点:

可获取,不可修改, 有序  (逗号是区别元祖的标识符 )

# 定义一个空元祖
tuplevar = ()
print(tuplevar , type(tuplevar))

#获取元祖中的元素
res = tuplevar[1]
res = tuplevar[-1]
print(res)

集合 set 

集合的特点:

无序  自动去重

# 定义一个空jihe
setvar = {} 
setvar = set()
print(setvar  , type(setvar))

# 定义一个集合
setvar = {"金城武","王俊凯","喻文波","王文"}
print(setvar , type(setvar))


# 自动去重
setvar = {"金城武","王俊凯","喻文波","王文","王文","王文","王文"}
print(setvar)

字典 dict

字典的特点:

键值对 储存的数据,表面上有序,实际上无序

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

#定义一个字段
dictvar = {"智多星":"吴用","花和尚":"鲁智深","浪里白条":"张顺"}

# 获取字典中的值
dictvar = {"智多星":"吴用","花和尚":"鲁智深","浪里白条":"张顺"}
res = dictvar["智多星"]
print(res)

# 修改字典中的值
dictvar = {"智多星":"吴用","花和尚":"鲁智深","浪里白条":"张顺"}
dictvar["智多星"] = "吴用"
print(dictvar)

字典的键和集合的值数据类型要求是( 可哈希的,不可变的)

不可变数据:

Number str tuple

可变数据:

list  set dict

关于哈希:

但凡提到哈希算法( hash) ,都是都是典型的无序特征.

目的为了更加均匀的吧数据分配到内存里,底层用的算法类似于取模,

Python3.6 版本以后,对字典做了优化,存储数据的时候用好像算法

但是在拿出数据的时候,重新按照定义字典时的顺序进行重新排序

所有看起来有序,实际上无序.

占位符

%d 整型占位符
strvar = “王金刚学习容易走神,买了%d个风油精,提神醒脑” % (5)
print(strvar)

%2d 占两位 原字符串默认居右
strvar = “白星今天%d岁” % (3)
print(strvar)
strvar = “白星今天%2d岁” % (3)
print(strvar)

%-2d 占两位 原字符串默认居左
strvar = “白星今天%-2d岁” % (30000)
print(strvar)

%f 浮点型占位符
strvar = “马春陪一个月开了%f工资” % (9.9)
print(strvar)

%.2f 小数点保留2位
strvar = “马春陪一个月开了%.2f工资” % (9.9)
print(strvar)

%f 存在四舍五入的情况
strvar = “马春陪一个月开了%.1f工资” % (9.876542342)
print(strvar)

%s 字符串占位符
strvar = “%s” % (“python31的同学们都有祖安人民的特质”)
print(strvar)

类型的转换

Number的强制转换( int flost bool coplex ) 

var1 = 13
var2 = 13.789
var3 = True
var4 = 5-7j
var5 = “9988”
var6 = “abcd4567”

# int强转换成整型
res = int(var2) # 13
res = int(var3) # False => 0 True => 1
res = int(var4) error
res = int(var5) # 9988
res = int(var6) error
print(res , type(res))

# float 强转换成浮点型
res = float(var1) # 13.0
res = float(var3) # True => 1.0 False => 0.0
res = float(var5) # 9988.0
print(res , type(res))

# complex 强制转换成复数
res = complex(var1) # 13 + 0j
res = complex(var2) # 13.789 + 0j
res = complex(var3) # False => 0j True => 1+0j
res = complex(var5) # 9988 + 0j
#res = complex(var6) error
print(res , type(res))

# bool 强制转换成布尔值
res = bool(None)
print(res , type(res))

bool为False的十种情况  

0 , 0.0 , False , 0j , ‘’,[],(),set(),{},None

默认创建一个该数据类型的值

int()  float()  bool()  complex()

res = int()
res = float()
res = bool()
res = complex()
print(res)

Number的自动转换( int flost bool coplex ) 

精度从低到高进行转换:
bool -> int -> float -> complex
bool + int
res = True + 100 # 1 + 100
print(res)
bool + float
res = True + 4.15 # 1.0 + 4.15
print(res
bool + complex
res = True + 3-6j # 1+0j + 3 - 6j
print(res)
int + float
res = 5 + 3.48 # 5.0 + 3.48
print(res)
int + complex
res = 10 + 4-3j # 10 + 0j + 4 - 3j
print(res)
float + complex
res = 5.68 + 5-100j # 5.68+0j + 5 - 100j
print(res)

容器类型数据的强制转换 ( str list tuple set dict ) 

strvar = ‘雷霆嘎巴,无情哈拉少,ZBCC’
listvar = [“曹晨光”,“温子月”,“吴洪昌”]
tuplevar = (“高学峰”,“葛龙”,“孙京华”,“白星”)
setvar = {“李志辉”,“马春陪”,“刘鑫炜”}
dictvar = {“lzh”:“气质非凡”,“mcp”:“高大威猛”,“lxw”:“气宇轩昂”}


str (容器 / Number 都可以转换)
强转成字符串,无非就是在原有的数据的基础上两边套上引号

list : 强制转换成列表
如果是字符串,会把每一个字符单独的作为一个元素放到列表中
如果是字典,只保留键,形成一套新的列表
如果是其他的容器,只是单纯的在原有数据的基础上换上[]

tuple : 强制转换成元组
如果是字符串,会把每一个字符单独的作为一个元素放到元组中
如果是字典,只保留键,形成一套新的元组
如果是其他的容器,只是单纯的在原有数据的基础上换上()

set : 强制转换成集合(自动去重)
如果是字符串,会把每一个字符单独的作为一个元素放到集合中(无序,自动去重)
如果是字典,只保留键,形成一套新的集合
如果是其他的容器,只是单纯的在原有数据的基础上换上{}

repr 可以原型化输出字符串,不转义字符(显示出引号)
print( repr(res) )

二级容器与等长的二级容器( list tuple set dict )

二级容器

二级列表
lst = [1,2,[3,4]]
二级元组
tup = (5,6,7,(8,9))
二级集合
setvar = {10,11,(12,13)}
二级字典
dic ={“a”:1,“b”:{“c”:3,“d”:4}}

等长的二级容器

里面的元素都是容器,并且容器里面的元素个数都相同
lst = [(1,2,3) , [4,5,6]]
lst = [(1,2) , [4,5]]

二级容器强转字典

强转成字典时 , 必须是等长的二级容器,里面的元素个数是2个
(1)外层是列表或者元组或者集合,里面的容器是元组或者列表(推荐)

lst = [("a",1),["b",2]]
tup = (("c",3),["d",4],) 
setvar = {(1,2),(3,4),("f3",3),("f4",4)}
res = dict(lst) # {'a': 1, 'b': 2}
res = dict(tup) # {'c': 3, 'd': 4}
res = dict(setvar) # {1: 2, 'f3': 3, 3: 4, 'f4': 4}

 (2)如果里面是集合,语法上是允许的但是所有局限性
lst = [{“a”,333},{“zz”,5}] # 因为集合无序,不符合定义的本意,不推荐使用
print(dict(lst))
(3)如果是字符串,语法上也是可以的但是有局限性
lst = [(“a”,1),“b2”] # 字符串长度只能2个
lst = [(“a”,1),“b23”] error
print( dict(lst) )