听说Python成为世界性语言了？ Python是怎么构建世界？基础在哪里？(一)

学习目标 ☀️：

⭐️⭐️⭐️
一周掌握 python 入门知识

---

学习内容☀️：

提示：这里可以添加要学的内容
例如：
1、 搭建 python 开发环境
2、 掌握 python 基本语法
3、 掌握条件语句
4、 掌握循环语句

---

学习时间：

1、 周一至周五晚上 7 点—晚上9点
2、 周六上午 9 点-上午 11 点
3、 周日下午 3 点-下午 6 点

---

作者简介：大家好，我是爱敲代码的小王，CSDN博客博主,Python小白
系列专栏：python入门到实战、Python爬虫开发、Python办公自动化、Python数据分析、Python前后端开发
如果文章知识点有错误的地方，请指正！和大家一起学习，一起进步
如果感觉博主的文章还不错的话，请三连支持一下博主哦
博主正在努力完成2023计划中：以梦为马，扬帆起航，2023追梦人

python入门到实战专栏：从入门到实战

Python爬虫开发专栏：从入门到实战

Python办公自动化专栏：从入门到实战

Python数据分析专栏：从入门到实战

Python前后端开发专栏：从入门到实战

Python程序的构成

⭐️⭐️⭐️ Python程序由模块组成。一个模块对应python源文件，一般后缀名是：.py
⭐️⭐️⭐️ 模块由语句组成。运行Python程序时，按照模块中语句的顺序依次执行
⭐️⭐️⭐️ 语句是Python程序的构造单元，用于创建对象、变量赋值、调用函数、控制语句等

代码的组织和缩进

很多编程语言通过字符(例如：花括号{})、关键字(例如： begain/end)来划分代码块。同时，在配合代码的缩进增加可读性。“龟叔”设计Python语言时，直接通过缩进来组织代码块。“缩进”成为了Python语法强制的规定。缩进时，几个空格都是允许的，但是数目必须统一。通常采用“四个空格”表示一个缩进。
同时，也要避免将“tab制表符”或者tab与空格混合的缩进风格。目前，常用的编辑器一般设置成：tab制表符就是4个空格

Python官方推荐的PEP-8代码风格详细说明，有兴趣的大佬可以参考：https://www.python.org/dev/peps/pep-0008/

使用\行连接符

一行程序长度是没有限制的，但是为了可读性更强，通常将一行比较长的程序分为多行。这是，我们可以使用\行连接符，把它放在行结束的地方。Python解释器仍然将它们解释为同一行。

a = [10,20,30,40,\
   50,60,70,\
   80,90,100]
b = 'abcdefg\
     hijklmn\
     opqrst\
     uvwxyz'
print(a)
print(b)

学习效果反馈

1. 关于python代码组织，正确的说法是:
A python中，也可以像c语言一样使用{ }表示缩进
B python中，强制使用缩进，一般4个空格表示一个缩进
C python中，缩进是可选的，不强制
D python中，解释器会自动加缩进，缩进不强制写也可以

2. 一行代码较长，变成多行，使用什么符号？
A 回车符
B / 行连接符
C \ 行连接符
D 使用分号

对象

1 Python中，一切皆对象。
2 每个对象由：标识（identity）、类型（type）、value（值）组成

源码：

a=3
print(a)
print(id(a))
print(type(a))
b='我爱你'
print(b)
print(id(b))
print(type(b))

内存示意图

学习效果反馈

1. 对象由三部分组成，是哪三部分:
A int，type，value
B int, class, value
C class, type, value
D id, type, value

2. 如下图形，对应的代码是：

A b=“88”
B b = 46806816
C b = 88
D b = “int”

引用

在Python中，变量也称为：对象的引用(reference)。变量存储的就是对象的地址。
变量通过地址引用了“对象”。

变量位于：栈内存（压栈出栈等细节，后续再介绍）。
对象位于：堆内存。
如下源代码对应的内存图：

a=3
b="我爱你"

学习效果反馈

1. 如下关于变量和对象说法，错误的是:
   A 变量也称为引用（引用了对象的地址）
   B 变量和对象都位于堆内存
   C 变量没有类型，对象有类型
   D 变量不需要声明类型，解释器可以自动确定所引用对象的类型

标识符规则

基本用法

【操作】使用Python帮助系统查看关键字

⚠️注：无需刻意去背关键字，后面都会学习。

Python标识符命名规则

开发中，我们通常约定俗称遵守如下规则：

学习效果反馈

1. 如下合法的标识符是:
   A a#123
   B 100vip
   C _good_student
   D if

变量和简单赋值语句

变量的声明和赋值

变量的声明和赋值：用于将一个变量绑定到一个对象上，格式： 变量名 = 表达式

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

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

print(a)

报错如下：

Traceback (most recent call last):
  File "C:\Users\webChubby\PycharmProjects\mypro01\mypy01.py", line 1, in <module>
    print(a)  NameError: name 'a' is not defined

变量 a 在被使用前未做赋值，因此报错： ’a’ is not defined

删除变量和垃圾回收机制

⭐️⭐️⭐️ 可以通过del语句删除不再使用的变量。
⭐️⭐️⭐️ 如果对象没有变量引用，就会被垃圾回收器回收，清空内存空间。

【操作】删除变量示例

a=123
del a
print(a)

报错如下：Traceback (most recent call last): File "C:\Users\webChubby\PycharmProjects\mypro01\m ypy01.py", line 3, in print(a) NameError: name 'a' is not defined

学习效果反馈

1. 如下代码的运行，说法正确的是：

a=123
del a
print(a)

A 可以正常运行
B 报错。a没有被定义
C 报错。不能删除a
D 报错。a不能被赋值123

常量

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

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

链式赋值

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

系列数据赋值给对应相同个数的变量（个数必须保持一致） a,b,c=4,5,6 相当于： a=4;b=5;c=6

【操作】使用系列解包赋值实现变量值交换

a,b=1,2
a,b=b,a  #变量值互换
print(a,b)

学习效果反馈

1. 执行代码 a,b,c=40,50,60 ，说法正确的是：
A a,b,c的值是最后的值：60
B 只有a被赋值40。b和c是0
C a,b,c的值是最初的值：40
D a是40，b是50，c是60

2. python中的常量，说法正确的是：
A python中的常量是真的常量，不能修改值
B python中的常量是逻辑上的常量，仍然可以修改值
C python中的常量命名一般是小写
D python中的常量命名一般用驼峰原则，比如： StudentNumber

最基本内置数据类型

python中变量没有类型，但是对象都有类型，python中最基本的内置数据类型：

1 整型 int
整数， 2345 , 10 , 50
2 浮点型 float
小数， 3.14 或者科学计数法 314e-2
3 布尔型 bool
表示真假，仅包含： True 、 False
4 字符串型 str
由字符组成的序列。 “abc” , ‘sxt’ , “王小鼠” , “Python小白猿”

数字和基本运算符

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

【操作】基本运算符的使用

a = 7/2  #3.5
a = 7//2 #3
a = 7%2  #1
a = 7%4  #3
a = 2**3 #8
#a = 3/0   #报错：ZeroDivisionError: division by zero

除数为0，会产生异常：

3/0Traceback (most recent call last): File "
<pyshell#31>", line 1, in 
3/0ZeroDivisionError: division by zero

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

divmod() 是一个函数，我们以后会详细介绍。他返回的是一个元组(后续将会学习)。

学习效果反馈

1. python中，内置的基本类型有哪些：
A 整型、数组、布尔型、字符串型
B 整型、浮点型、布尔型、字符型
C 整型、浮点型、布尔型、字符串型
D 整型、数组、布尔型、字符型

2. 如下代码，运行结果是：
a = 7/2 a = 7//2 a = 7%2
A 3, 3.5 3
B 3.5, 3, 1
C 3.5, 3, 3
D 4, 3, 1

整数

三种进制

这三种进制可以非常方便的进行“位运算”操作。位运算后续将会介绍。
【操作】测试不同进制

>>> 12
12
>>> 0b101
5
>>> 0o19
SyntaxError: invalid syntax
>>> 0o10
8
>>> 0xff
255
>>> 0xf
15
>>> 0x10
16

使用int()实现类型转换：

>>> int("456")
456
>>> int("456abc")
Traceback (most recent call last):
  File "", line 1, in <module>
    int("456abc")
ValueError: invalid literal for int() with
base 10: '456abc'
>>> int("456.78")
Traceback (most recent call last):
  File "", line 1, in <module>
    int("456.78")
ValueError: invalid literal for int() with
base 10: '456.78'
>>>

自动转型：

整数和浮点数混合运算时，表达式结果自动转型成浮点数。比如： 2+8.0 的结果是 10.0

整数可以任意大

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

googol = 10**100
>>>googol100000000000000000000000000000000000
000000000000000000000000000000000000000000000
00000000000000000000

Googol也是Google最初的名字，这也是Google最初的含义。

学习效果反馈

1. python3中，整数的表示范围是：
A 任意大，无限大
B 表示±21亿范围
C 表示±2的64次方范围
D 表示0-65536范围

2. 关于python中整型和浮点型，如下说法错误的是：
A 16进制是0x开头
B 3+5.0 结果是浮点数
C int(“888”)结果是888
D int(“888aaa”)结果是888

浮点数 float

学习效果反馈

1. python3中浮点数，如下说法错误的是：
A 314E-2,表示的是：3.14
B a+=2，相当于a = a+2
C round(value) 可以进行四舍五入，并修改了value对象的值
D float(“3.1415”)可以转成浮点数： 3.1415

时间的表示

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

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

import time
b = int(time.time())
totalMinutes = b//60
totalHours = totalMinutes//60
totalDays = totalHours//24
totalYears = totalDays//365  #忽略闰年情况

学习效果反馈

1. python中，关于时间的表示，错误的是：
A 通过time.time()获得当前时刻所代表的的数字，返回的是浮点数
B 使用time，需要 import time
C 时间是从1970.1.1 0:0:0 开始计算
D int(time.time())返回的是当前时刻代表的毫秒数

【操作】定义多点坐标绘出折线并计算起始点和终点距离

import turtle
import math
#定义多个点的坐标
x1,y1 = 100,100
x2,y2 = 100,-100
x3,y3 = -100,-100
x4,y4 = -100,100
#绘制折线
turtle.penup()
turtle.goto(x1,y1)
turtle.pendown()
turtle.goto(x2,y2)
turtle.goto(x3,y3)
turtle.goto(x4,y4)
#计算起始点和终点的距离
distance = math.sqrt((x1-x4)**2 + (y1-y4)**2)
turtle.write(distance)
turtle.done()     #该语句让程序等待，而不是直接退出窗口

运行结果：

学习效果反馈

1. python的海龟绘图模块的使用，错误的是：
   A 需要导入turtle模块
   B turtle.done() 可以让程序等待，而不是直接退出窗口
   C 小海龟默认的坐标是(0,0)
   D turtle是内置模块，不需要导入即可使用

布尔值

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

a = True
b = 3
c = a+b #c的值是：4
print(c)
print('空字符串的布尔类型的值:',bool("")) 
#False
print('空列表布尔类型的值:',bool([])) 
#False
print('None布尔类型的值:',bool(None)) 
#False
print('0布尔类型的值:',bool(0)) 
#False
print('字符串True和False转成布尔都是
True：',bool("False")) #True

运算符

逻辑运算符

#测试逻辑运算符
a,b,c=10,20,30
print((a<b) and (b<c))   #and并且 输出结果是
True
print((a>b) or (b>c))    #or或者   输出结果是
False
print(not(b<c))         #not非     输出结果是
False

比较运算符

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

a = 4
print(a<=30)
#关系运算符可以连用
if(3<a<10):
    print("a在3和10之间")

位运算符

按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如表所示。

a = 0b11001
b = 0b01000
print(bin(a|b))   #bin()可以将数字转成二进制表示 '0b11001'
print(bin(a&b))   #与
print(bin(a^b))   #异或
print(3<<2)    #左移1位相当于乘以2.左移两位相当于：3*4
print(20>>1)   #右移移位相当于除以2

加法操作补充

乘法操作补充

增强赋值运算符(补充)
复合赋值可以让程序更加精炼，提高效率。

⚠️与 C 和 JAVA 不一样， Python 不支持自增(++)和自减(–)

学习效果反馈

1. python中关于布尔类型说明，错误的是：
   A bool(“”) 结果是： False
   B bool(0) 结果是： False
   C bool(“False”) 结果是： False
   D c=True+5 结果是： 6

2. 如下代码，正确结果是：
   a,b,c=10,20,30 print((ab) or (b>c)) print(not(b
A False False False
B False True False
C False False True
D True False False

同一运算符

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

a=20
b=20
c=30
print("a和b是同一个对象",a is b)   #执行结果:True
print("a和c是同一个对象",a is c)   #执行结果False
print("a和c不是同一个对象",a is not c)   #执行结果True

整数缓存问题


【操作】同一运算符测试

a = 1000
b = 1000
a == b   #True
a is b   #命令行下是False。 文件下执行是True
c = 10
d = 10
c is d   #True

成员运算符
成员运算符测试实例中包含了一系列的成员，包括字符串，列表或元组。

a = "python"
b = "py"
print(b in a)        #True
c = [10,20,30]
print(10 not in c)   #False

运算符优先级问题
如下优先级，从高到低。

#测试运算符优先级
a,b,c,d=20,10,15,5
e=(a+b)*c/d        #30*15/5
print('(a+b)*c/d的执行结果:',e)
e=(a+b)*(c/d)      #30*(15/5)
print('(a+b)*(c/d)的执行结果：',e)
e=a+(b*c)/d        #20+150/5
print('a+(b*c)/d的执行结果：',e)

实际使用中，记住如下简单的规则即可，复杂的表达式一定要使用小括号组织。

基本运算符总结

学习效果反馈

1. 如下代码，错误的是：
   A 10 in [10,20,30] 结果是： True
   B “py” in “python” 结果是： True
   C 100 not in [10,20,30] 结果是： False
   D “hello” is “hello" 结果是： True