Python ( 学习基础篇第一部 )

注释

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

注释的分类

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

注释的注意点

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

变量

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

变量的概念

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)

变量的命名规则

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

变量的交换

通用写法:

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)

变量的缓存机制

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

Number 部分
对于整型而言，-5~正无穷范围内的相同值 id一致
对于浮点数而言，非负数范围内的相同值 id一致
布尔值而言,值相同情况下，id一致
复数在实数+虚数这样的结构中永不相同(只有虚数的情况例外)
容器类型部分
字符串和空元组相同的情况下，地址相同
列表，元组，字典，集合无论什么情况 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 = “文哥是这个世界上,
我认为最帅的男人”

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

字符串原型化输出

#元字符串 r"字符串" 不转义字符,原型化输出字符串
strvar = r"E:
ython31	ay2"
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) )

好好学习，天天向上。

Python ( 学习 基础篇第一部 )

目录

注释