Python从入门到就业（详细）

python

对象

python中，一切皆为对象。

每个对象由：

标识（identity）//用来编号的，寻找对象的。

类型（tupe）//是什么样子的对象，是字符串呢还是其他类型

value（值）//存放的不一样的值

1. 标识用于唯一标识对象，通常对应于对象在计算机内存中的地址。使用内置函数 id(obj)可返回对象 obi的标识。
2. 类型用于表示对象存储的“数据”的类型。类型可以限制对象的取值范围以及可执行的操作。可以使用 type(obj)获得对象的所属类型。
3. 值表示对象所存储的数据的信息。使用 print(obj)可以直接打印出值

个内存块对象的本质就是拥有特定的值，支持特定类型的相关操作

a = 3
//将3的变量赋给a
id(3)
153137233
//3的地址
type(3)
<class 'int'>
//3是一个int类型
print(a)
3
//输出a的值

它在内存中所存在的形式：

引用

在 Python 中，变量也成为:对象的引用。因为，变量存储的就是对象的地址。变量通过地址引用了“对象”

变量位于: 栈内存(压栈出栈等细节，后续再介绍 )。

对象位于:堆内存

·Python 是动态类型语言
变量不需要显式声明类型。根据变量引用的对象，Python 解释器自动确定数据类型

·Python 是强类型语言
每个对象都有数据类型，只支持该类型支持的操作

标识符

基本用法

标识符:用于变量、函数、类、模块等的名称。
标识符有如下特定的规则

1.区分大小写。如 : sxt 和 SXT 是不同的

2.第一个字符必须是字母、下划线。其后的字符是: 字母、数字、下划线

3.不能使用关键字。比如 :if、 or、while 等。

4.以双下划线开头和结尾的名称通常有特殊含义，尽量避免这种写法。比如 : init 是类的构造函数。

使用 Python 帮助系统查看关键字

Python标识符命名规则

开发中，我们通常遵守如下规则

变量和简单赋值语句

变量的声明和赋值

变量的声明和赋值用于将-变量绑定到一个对象上，格式如下

变量名=表达式

最简单的表达式就是字面量。比如: a =123 。运行过程中，解释器先运行右边的表达式,生成一个代表表达式运算结果的对象;然后，将这个对象地址赋值给左边的变量。

变量在使用前必须先初始化（先被赋值）

>>>my_name
Tracedack (mosr tecent call lasr):
    File "<pyshell#17>",line 1,in<module>
    	my_name
NameError:name'my_name'is not defined

变量my_name在被使用1前未被赋值，所以报错“'my_name’is not defined”

删除变量和垃圾回收机制

可以通过del语句删除不在使用的变量。

>>> a=123
>>> del a
>>> x
Traceback (most recent call last):
    File "<pyshell#20>", line 1, in <module>
    x
NameError: name 'x' is not defined

如果对象没有变量引用，就会被垃圾回收器回收，清空内存空间。

链式赋值

链式赋值用于同一个对象赋值给多个变量。

x=y=123 相当于:x=123;y=123

系列解包赋值

系列数据赋值给对应相同个数的变量(个数必须保持一致 )

>>>a,b,c=4,5,6相当于:a=4;b=5;c=6

使用系列解包赋值实现变量交换

>>> a,b=1,2
>>> a,b=b;a
>>> print(a,b)

常量

ython .不支持常量，即没有语法规则限制改变一个常量的值。我们只能约定常量的命名规则，以及在程序的逻辑上不对常量的值作出修改。

>>> MAX SPEED = 120
>>> print(MAX_SPEED)
120
>>> MAX SPEED = 140 #实际是可以改的。只能逻辑上不做修改
>>> print(MAX SPEED)
140

最基本内置数据类型介绍

每个对象都有类型，python 中最基本的内置数据类型

1.整型
整数，2345,10,50

2.浮点型
小数，3.14或者科学计数法 314e-2

3.布尔型
表示真假，仅包含: True、False

4.字符串型

由字符组成的序列。“abc”“sxt”

数字

Python 支持整数(如 : 50,520)和浮点数(如 : 3.14,10.0, 1.23e2)，我们可以对数字做如下运算。

运算符	说明	示例	结果
+	加	1+1	2
-	减	2-1	1
*	乘	1*1	1
/	浮点除法	8/2	4.0
//	整数除法	7/2	3
%	取模	7%4	3
**	幂	2**3	8

使用divmod(13,3)函数同时得到商和余数：

>>>divmid(13,3)
(4,1)

divmod()是一个函数，他返回的是一个元组。

整数

Python 中，除 10 进制，还有其他三种进制
0b 或 0B，二进制 0，1
00或 00，八进制 0，1，2，3，4，5，6，7
0x或 0X，十六进制 0，1，2，3，4，5，6，7，8，9，a，b，c，d，e，f
这三种进制方便的进行“位运算”操作。

使用 int0实现类型转换

1.浮点数直接舍去小数部分。如 : int9.9)结果是 :9

2.布尔值 True 转为 1，False 转为 0。如:int(True)结果是 1

3.字符串符合整数格式(浮点数格式不行)则直接转成对应整数，否则报错

>>>int("456")
456
>>>int(3.1415)//类型转化时直接干掉小数
3
>>>int(True)
1
>>>int(False)
0

自动转型 :

整数和浮点数混合运算时，表达式结果自动转型成浮点数。

比如 :2+8.0 的结果是10.0

整数可以有多大

Python2中，int 是32位，可以存储从-2147483648到2147483647的整数(约21亿)。Long 类型是 64 位，可以存储:-263–263-1 之间的数值。Python3 中，int 可以存储任意大小的整数，long 被取消。我们甚至可以存储下面的

Python3 中可以做超大数的计算，而不会造成“整数溢出“，这也是 Python 特别适合科学运算的特点。

浮点数

浮点数，称为 float。
浮点数用axb^9形式的科学计数法表示。比如:3.14，表示成:314E-2 或者 314e-2.
这些数字在内存中也是按照科学计数法存储。

类型转换和四舍五入

1.类似于 int()，我们也可以使用 float()将其他类型转化成浮点数
2.整数和浮点数混合运算时，表达式结果自动转型成浮点数。比如:2+8.0 的结果是 10.0
3.round(value)可以返回四舍五入的值
注:但不会改变原有值，而是产生新的值

增强型赋值运算符

运算符+,-,*,/,//,**和赋值符=结合可以构成“增强型赋值运算符”。

a=a+1 等价于： a +=1

​ 增强型赋值运算符

运算符	例	等价
+=	a+=2	a=a+2
-=	a-=2	a=a-2
*=	a*=2	a=a*2
/=	a/=2	a=a/2
//=	a//=2	a=a//2
**=	a**=2	a=a**2
%=	a%=2	a=a%2

注：“+=”中间不能加空格！

时间的表示

计算机中时间的表示是从“1970 年1月1日 00:0:00”开始，以毫秒(1/1000 秒)进行计算。我们也把 1970 年这个时刻成为“unix 时间点”这样，我们就把时间全部用数字来表示了。

>>>import time #导入时间库
>>>time.time()
1683718398.2782423

>>> b = int(time.time)
>>> b = int(time.time())
>>> b   
1683718520
>>> totalMinutes = b/60
>>> totalMinutes
28061975.333333332
>>> totalMinutes = b//60
>>> totalMinutes
28061975
>>> totalHours = totalMinutes//60
>>> totalHours
467699
>>> totalDaye = totalHours//24
>>> totalDaye
19487

python 中可以通过 time.time() 获得当前时刻，返回的值是以秒为单位，带微秒(1/1000毫秒)精度的浮点值。例如: 1683718398.2782423。

​ 定义多点坐标绘出折线并计算起始点和终点距离

import turtle 
import math	#导入模块

#定义多个点的坐标
xl,yl = 100,100
x2,y2 = 100,-100
x3,y3 = -100,-100
x4,y4 = -100,100

#绘制折线
turtle. penup()
turtle.goto(xl,y1)
turtle. pendown()

turtle. goto(x2,y2)
turtle. goto(x3,y3)
turtle. goto(x4, y4)

#计算起始点和终点的距离

distance = math.sqrt((xl-x4)**2 + (yl-y4)**2)

turtle.write(distance)

布尔值

True，False

Python2 中没有布尔值，直接用数字0表示 False,用数字1表 True。Python3 中，把 True 和 False 定义成了关键字，但他们的本质还是1和0，甚至可以和数字相加。

>>> a =True
>>> b = 3
>>> a+b
4

比较运算符

所有比较运算符返回1表示真，返回 0表示假。这分别与特殊的变量 True 和 False 等价
以下假设变量a为15，变量b为30 :

运算符	描述	例子
==	等于- 比较对象的值是否相等	(a == b) 返回 False。
!=	不等于- 比较两个对象的值是否不相等	(a != b) 返回 true.
>	大于- 返回x是否大于y	(a > b) 返回 False。
<	小于 - 返回x是否小于 y。	(a < b) 返回 true。
>=	大于等于 - 返回是否大于等于y。	(a >= b) 返回 False。
<=	小于等于 - 返回x 是否小于等于 y。	(a <= b) 返回 true.

逻辑运算符

运算符	格式	说明
or逻辑或	x or y	x为 true，不计算y，则返回 truex 为 false，则返回 y
and逻辑与	x andy	x为 true，则返回y的值 x为 false，不计算y，则返回 false
not逻辑非	not x	x为 true，返回false x为 false，返回 true

同一运算符

同一运算符用于比较俩个对象的存储单元，实际比较的是对象的地址。

运算符	描述
is	is 是判断两个标识符是不是引用同一个对象
is not	is not 是判断两个标识符是不是引用不同对象

is 与 == 区别 :

​ is 用于判断两个变量引用对象是否为同一个，既比较对象的地址。
​ == 用于判断引用变量用对象的值是否相等，默认调用对象的 eq_()方法

​ · 整数缓存问题
Python 仅仅对比较小的整数对象进行缓存(范围为[-5,256]) 缓存起来，而并非是所有整数对象。需要注意的是，这仅仅是在命令行中执行，而在 Pycharm 或者保存为文件执行，结果是不-样的，这是因为解释器做了一部分优化(范围是[-5,任意正整数])

​ ·总结
1、isI比较两个对象的 id 值是否相等，是否指向同一个内存地址；
2、== 比较的是两个对象的内容是否相等，值是否相等;
3、小整数对象[-5,256]在全局解释器范围内被放入缓存供重复使用
4、is 运算符比 == 效率高，在变量和 None 进行比较时，应该使用 is。

字符串

字符串的特点

​ 很多人初学编程时，总是担心自己数学不行，潜意识里认为数学好才能编程。实际上大多数程序员打交道最多的是“字符串”而不是“数字”。因为，编程是用来解决现实问题的，因此逻辑思维的重要性远远超过数学能力。
​ 字符串的本质是:字符序列。Python 的字符串是不可变的，我们无法对原字符串做任何修改。但，可以将字符串的一部分复制到新创建的字符串，达到“看起来修改”的效果。

​ Python 不支持单字符类型，单字符也是作为一个字符串使用的。

字符串的编码

​ Python3 直接支持Unicode，可以表示世界上任何书面语言的字符。Python3 的字符默认就是 16 位 Unicode 编码，ASCII 码是 Unicode 编码的子集。

​ 使用内置函数 ord0可以把字转换成对应的 Unicode码;

​ 使用内置函数 chr0可以把+进制数字转换成对应的字符

>>> ord('A')
65
>>> ord('高')
39640
>>> chr(66)
B
>>> ord('淇')
28103

引号创建字符串

我们可以通过单引号或双引号创建字符串。例如:a=’ abc’ ; b=”sxt"

使用两种引号的好处是可以创建本身就包含引号的字符串，而不用使用转义字符。例如:

>>> a ="I'm a teacher!"
>>> print(a)
I'm a teacher!
>>> b = 'my name is "TOM"
>>> print(b)
my_name is "TOM

连续三个单引号或三个双引号，可以帮助我们创建多行字符串。例如 :

>>> resume =""name="gaogi"
company="sxt"
age=18
lover="Tom"""
>>> print(resume)
name="gaoqi"
company="sxt"	age=18
lover="Tom"

空字符串和len()函数

Python允许字符串的存在，不包含任何且长度为0。

例如：

>>>c=''
>>>len(c)
0

len()用于计算字符串含有多少个字符。

例如：

>>>d='asd猴'
>>>len(d)
4

转义字符

可以使用“+特殊字符”实现某些难以用字符表示的效果。比如 : 换行等。常见的转义字符有这些:

转义字符	描述
\（在行尾时）	续行符
\\	反斜杠字符
\’	单引号
\"	双引号
\b	退格（Backspace）
\n	换行
\t	横向制表符
\r	回车

字符串的拼接

1.可以使用+将多个字符串拼接起来。例如 :’aa’ +’ bb’==>'aabb

​ (1)如果+两边都是字符串，则拼接
​ (2) 如果+两边都是数字，则加法运算。
​ (3) 如果+两边类型不同，则抛出异常。
2.可以将多个字面字符串直接放到一起实现拼接。例如 : aa’’bb’ ==>’ aabb’

>>>a =a'sxt'+'gaoqi'
>>>a
'sxtgaoqi'
>>> b = 'sxt''gaoqi'
>>> b
'sxtgaoqi'

字符串复制

使用*可以实现字符串复制

>>>a ='Sxt'*3
>>>a
'SxtSxtSxt'

不换行打印

我们前面调用 print 时，会自动打印一个换行符。有时，我们不想换行，不想自动添加换行符。我们可以自己通过参数 end =“任意字符串”。实现未尾添加任何内容：

建立源文件mypy_06.py :

print("sxt",end='')
print("sxt",end='##')
print("sxt")
结果：sxt sxt##sxt

从控制台读取字符串

我们可以使用 input()从控制台读取键盘输入的内容。

>>>myname = input("你的名字：")
请输入名字：猴哥
>>>myname
'猴哥'

str()实现数字转型字符串

str(5.20)==> '5.20' 
str(3.14e2)==>'314.0'  ##3.14的二次方

当我们调用 print0函数时，解释器自动调用了 str0将非字符串的对象转成了字符串。我们在面向对象章节中详细讲解这部分内容。

使用[]提取字符

字符串的本质就是字符序列，我们可以通过在字符串后面添加D，在0里面指定偏移量可以提取该位置的单个字符。
正向搜索：
最左侧第一个字符，偏移量是 0，第二个偏移量是1，以此类推。直到len(str)-1为止。
反向搜索:
最右侧第一个字符，偏移量是- 倒数第二个偏移量是-2以此类推直到-len(str)为止。

使用[]提取字符串中的字符

>>> a ='abcdefghijklmnopqrstuvwxyz'
>>> a
'abcdefghijklmnopqrstuvwxyz'
>>> a[0]
'a'
>>> a[26-1]
'z'
>>> a[-40]
Traceback (most recent call last):
    File "<pyshell#91>", line 1, in <module>
    a[-40]
IndexError: string index out of range

replace()实现字符串的替换

字符串是“不可改变”的，我们通过1可以获取字符串指定位置的字符，但是我们不能改变字符串。我们尝试改变字符串中某个字符，发现报错了：

>>> a = 'abcdefghijklmnopqrstuvwxyz'
>>> a
'abcdefghijklmnopqrstuvwxyz'
>>> a[3]='侯'
Traceback (most recent call last):
    File "<pyshell#94>", line 1, in <module>
    a[3]='侯'
IypeError: 'str' object does not support item assignment

字符串不可改变。但是，我们确实有时候需要替换某些字符。这时，只能通过创建新的字符串来实现。

>>> a ='abcdefghijklmnopqrstuvwxyz'
>>> a
'abcdefghijklmnopqrstuvwxyz'
>>> a.replace('c''侯')
'ab 高 defghijklmnopqrstuvwxyz'

整个过程中，实际上我们是创建了新的字符串对象，并指向了变量 a，而不是修改了以前的字符串。

字符串切片slice操作

切片 slice 操作可以让我们快速的提取子字符串。标准格式为[起始偏移量 start : 终止偏移量 end : 步长 step]

典型操作(三个量为正数的情况)如下:

操作和说明	示例	结果
[:] 提取整个字符串	"abcdef” [:]	“abcdef”
[start;]从 start 索引开始到结尾	“abcdef”[2:]	“cdef”
[:end]从头开始知道 end-1	"abcdef”[:2]	“ab”
[start:end]从 start到 end-1	"abcdef”[2:4]	“ab”
[start:=end:step]从 start 提取到 end-1，步长是 step	"abcdef”[1:5:2]	“bd”

注：包头不包尾

其他操作(三个量为负数)的情况：

示例	说明	结果
“abcdefghijklmnopqrstuvwxyz”[-3:]	倒数三个	“xyz”
“abcdefghijklmnopqrstuvwxyz”[-8:-3]	倒数第八个到倒数第三个(包头不包尾)	”stuvw“
“abcdefghijklmnopqrstuvwxyz”[::-1]	步长为负，从右到左反向排序	”zyxwvutsrqponmlkjihgfedcba“

切片操作时，起始偏移量和终止偏移量不在[0,字符串长度-1]这个范围，也不会报错。起始偏移量小于 0 则会当做0，终止偏移量大于“长度-1”会被当成-1。

例如 :

>>> "abcdefg"[3:50]
'defg'
>>> sxtsxtsxtsxtsxt[::3]

split()分割和join()合并

split0可以基于指定分隔符将字符串分隔成多个子字符串(存储到列表中)。如果不指定分隔符，则默认使用空白字符(换行符/空格/制表符)。

示例代码如下 :

>>> a ="to be or not to be"
>>> a.split0
['to', "be', 'or', 'not', 'to', "be"]
>>> a.split( "be")
['to ' ' or not to ' , "]

join()的作用和 split()作用刚好相反，用于将一系列子字符串连接起来。

示例代码如下:

>>>a =['sxt''sxt100','sxt200']
>>>*join(a)
'sxt*sxt100*sxt200'

join()与+拼接符的区别

import time

timo01 = time.time() #起始时间

a = ""
for i in range(1000000):
    a += "sxt"

timo02 = time.time() #终止时刻

print("运算时间:"+str(time02-time01))

timo03 = time.time() #起始时间

li = []
for i in range(1000000):
    li.append("sxt")
a = "",join(li)

timo04 = time.time() #终止时刻

print("运算时间:"+str(time04-time03))

测试结果

拼接字符串要点:

使用字符串拼接符+，会生成新的字符串对象，因此不推荐使用+来拼接字符串。推荐使用join 函数，因为join 函数在拼接字符串之前会计算所有字符串的长度，然后逐一拷贝仅新建一次对象。

字符串驻留机制和字符串比较

字符串驻留:仅保存一份相同且不可变字符串的方法，不同的值被存放在字符串驻留池中Python 支持字符串驻留机制，对于符合标识符规则的字符串( 仅包含下划线(_)、字母和数字)会启用字符串驻留机制驻留机制。

>>>a="abd 33"
>>> b ="abd 33"
>>> a is b
True
>>>c="dd#"
>>>d ="dd#"
>>> c is d
False
>>> str1 ="aa"
>>> str2 ="bb"
>>> str1+str2 is"aabb"

字符串比较和同一性

我们可以直接使用==,!=对字符串进行比较，是否含有相同的字符。

我们使用is /not is，判断两个对象是否同一个对象。比较的是对象的地址，即id(obj1)是否和 id(obj2)相等。

成员操作符

in /not in 关键字，判断某个字符(子字符串)是否存在于字符串中。

字符串常用方法汇总

字符串有很多常用的方法，我们需要熟悉。我们通过表格将这些方法汇总起来，方便大家查阅。希望大家针对每个方法都做一次测试。

常用查找方法

我们以一段文本作为测试
a=”我是侯景轩,今年 58 岁了,我在美国加利福尼亚大学上班。我的儿子叫小侯，他28 岁了。我是一个编程教育的普及者，希望影响 6000 万学习编程的中国人。我儿子现在也开始学习编程，希望他28 岁的时候可以超过我“

方法和使用示例	说明	结果
len(a)	字符串长度	105
a.startswith(“我是侯景轩”)	以指定字符串开头	True
a.endswith(“过我”)	以指定字符串结尾	True
a.find(“侯”)	第一次出现指定字符串的位置	2
a.rfind(“侯”)	最后一次出现指定字符串的位置	35
a.count(“侯”)	指定字符出现几次	2
a.isalnum()	所有字符全是字母或数字	False

去除首尾信息

我们可以通过 strip0去除字符串首尾指定信息。通过lstrip0去除字符串左边指定信息rstrip0去除字符串右边指定信息。

去除字符串首尾信息

>>> "*s*x*t*".strip("*")
's*x*t'
>>> "*s*x*t*".lstrip("*")
's*x*t*'
>>> "*s*x*t*".rstrip("*")
'*s*x*t'
>>>" sxt ".strip()
'sxt'

大小写转换

编程中关于字符串大小写转换的情况，经常遇到。我们将相关方法汇总到这里。为了方便学习，先设定一个测试变量 :

​ a= “gaoqi love programming, love SXT”

示例	说明	结果
a.capitalize()	产生新的字符串,首字母大写	‘Gaoqi love programming, love sxt’
a.title()	产生新的字符串,每个单词都首字母大写	‘Gaoqi Love Programming, Love Sxt’
a.upper()	产生新的字符串,所有字符全转成大写	’GAOQI LOVE PROGRAMMING, LOVE SXT’
a.lower()	产生新的字符串,所有字符全转成小写	‘gaoqi love programming, love sxt’
a.swapcase()	产生新的,所有字母大小写转换	'GAOQI LOVE PROGRAMMING，LOVE sxt‘

格式排版

center()、ljust()、rjust()这三个函数用于对字符串实现排版。示例如下

>>> a="SXT"
>>> a.center(10,"*")
'****SXT****'
>>> a.center(10)
' SXT '