1.Python 引入（字面量、注释、变量、数据类型、数据类型转换、标识符、运算符、字符串扩展）

一、字面量

1、基本介绍

• 在代码中，被写直接下来的、不需要通过变量存储的值，称之为字面量

2、常用值类型

类型	说明
数字（Number）	整数（int），例如：10、-10 浮点数（float），例如：12.34、-12.34 复数（complex），例如：4 + 3j，以 j 结尾表示复数 布尔（bool），True 表示真，数字记作 1，False 表示假，数字记作 0
字符串（String）	描述文本的一种数据类型，由任意数量的字符组成，例如，中文、英文、符号、数字等 注：在 Python 中，字符串需要用双引号 "" 包围起来，即被双引号包围起来的，都是字符串
列表（List）	有序的可变序列，Python 中使用最频繁的数据类型，可以有序记录一堆数据
元组（Tuple）	有序的不可变序列，可以有序记录一堆不可变的数据
集合（Set）	无序不重复集合，可以无序记录一堆不重复的数据
字典（Dictionary）	无序 Key - Value 集合，可以无序记录一堆 Key - Value 型数据

3、基本使用

类型	程序中编写	说明
整数	10，-10	和现实中的写法一致
浮点数	12.34、-12.34	和现实中的写法一致
字符串	"Hello World"	程需要加上双引号

10
12.34
"Hello World"

print(10)
print(12.34)
print("Hello World")

• 输出结果

10
12.34
Hello World

---

二、注释

1、基本介绍

1. 注释是在程序代码中对程序代码进行解释说明的文字

2. 注释不是程序，不能被执行，只是对程序代码进行解释说明，让别人可以看懂程序代码的作用，能够大大增强程序的可读性

2、注释的分类

1. 单行注释：以井号 # 开头

# 我是单行注释

2. 多行注释：以一对三个双引号 """ 引起来，也可以以一对三个单引号 ''' 引起来

"""
    我是多行注释
    我是多行注释
"""

'''
    我是多行注释
    我是多行注释
'''

• 注：多行注释一般对 Python 文件、类或方法进行解释

3、基本使用

"""
    1.演示各类字面量的写法
    2.通过 print 语句输出各类字面量
"""

# 编写一个整数字面量
10

# 编写一个浮点数字面量
12.34

# 编写一个字符串字面量
"Hello World"

# 通过 print 语句输出各类字面量
print(10)
print(12.34)
print("Hello World")

4、注释问题

编号	问题	回答
1	单行注释中能否使用多行注释？	不能
2	多行注释中能否使用单行注释？	能
3	多行注释中能否使用多行注释？	不能

---

三、变量

1、基本介绍

1. 变量是在程序中用于存储数据，且变量的值可以发生改变

2. 变量的值可以发生改变

2、变量定义

【变量名称】 = 【变量值】

3、基本使用

# 定义一个变量，用来记录钱包的余额
money = 60

# 输出变量记录的内容
# print 语句通过使用逗号（,）分隔来输出多份内容
print("钱包余额：", money)

# 买了一个冰淇淋，花费 10 元
money = money - 10

# 输出变量记录的内容
print("买了一个冰淇淋，花费 10 元，钱包余额：", money)

• 输出结果

钱包余额： 60
买了一个冰淇淋，花费 10 元，钱包余额： 50

---

四、数据类型

1、基本介绍

• 在入门阶段，主要接触如下三类数据类型

类型	描述	说明
string	字符串类型	用引号引起来的数据都是字符串
int	整型（有符号），数字类型	存放整数，如 -1，10，0 等
float	浮点型（有符号），数字类型	存放小数，如 -2.33, 6.66 等

2、type() 语句

（1）基本介绍

• 可以通过 type() 语句来得到数据的类型

type(【数据】)

（2）基本使用

1. 在 print 语句中，直接输出类型信息

print(type(10)) # <class 'int'>
print(type(1.23)) # <class 'float'>
print(type("Hello World")) # <class 'str'>

2. 用变量存储 type() 的结果

int_type = type(10)
float_type = type(1.23)
string_type = type("Hello World")

print(int_type) # <class 'int'>
print(float_type) # <class 'float'>
print(string_type) # <class 'str'>

3. 查看变量存储的数据的类型

name = "jack"
age = 20
score = 95.5

print(type(name)) # <class 'str'>
print(type(age)) # <class 'int'>
print(type(score)) # <class 'float'>

4. 数据类型的判断

data1 = 10
data2 = "Hello"

print(type(data1) == int) # True
print(type(data1) == str) # False
print(type(data2) == int) # False
print(type(data2) == str) # True

• 注：变量没有类型，它存储的数据有类型

---

五、数据类型转换

1、为什么要类型转换

• 数据类型之间，在特定的场景下，是可以相互转换的，如字符串转数字、数字转字符串等

• 数据类型转换，将会是以后经常使用的功能，如：

1. 从文件中读取的数字，默认是字符串，需要转换成数字类型

2. input() 语句，默认结果是字符串，若需要数字也需要转换

3. 将数字转换成字符串用以写出到外部系统

2、常见的转换语句

语句(函数)	说明
int(x)	将 x 转换为一个整数
float(x)	将 x 转换为一个浮点数
str(x)	将对象 x 转换为字符串

• 注：字符串不可以随意转换成数字，字符串内必须只有数字才可以

3、基本使用

# 将字符串类型转换为数字
int_num = int("10")
print(type(int_num), int_num)

float_num = float("1.23")
print(type(float_num), float_num)

print("------------------------------")

# 将数字类型转换为字符串
int_str = str(123)
print(type(int_str), int_str)

float_str = str(123.456)
print(type(float_str), float_str)

print("------------------------------")

# 整数转换为浮点数
num1 = float(20)
print(type(num1), num1)

print("------------------------------")

# 浮点数转转换为
num2 = int(6.66)
print(type(num2), num2)

• 输出结果

<class 'int'> 10
<class 'float'> 1.23
------------------------------
<class 'str'> 123
<class 'str'> 123.456
------------------------------
<class 'float'> 20.0
------------------------------
<class 'int'> 6

---

六、标识符

1、什么是标识符

• 在 Python 中，我们可以给很多东西起名字，比如：变量的名字、方法的名字、类的名字等等，这些名字，我们把它统一的称之为标识符，用来做内容的标识

• 所以，标识符是在编程的时候所使用的一系列名字，用于给变量、类、方法等命名

2、标识符命名规则

（1）内容限定

• 标识符命名中，只允许出现：英文、中文、数字和下划线（_）这四类元素，其余任何内容都不被允许

• 不推荐使用中文

• 数字不可以开头

（2）大小写敏感

• 大写和小写，是完全能够区分的

name = "jack"
Name = "smith"

print(name) # jack
print(Name) # smith

（3）不可使用关键字

• Python 中有一系列单词，称之为关键字，关键字在 Python 中都有特定用途，不可以使用它们作为标识符

3、标识符命名规范

• 目前只接触到了变量，所以，目前介绍变量的命名规范

（1）见名知意

• 明了：尽量做到，看到名字，就知道是什么意思

• 简洁：尽量在确保“明了”的前提下，减少名字的长度

（2）下划线命名法

• 多个单词组合变量名，要使用下划线做分隔，如 student_nickname

（3）英文字母全小写

• 命名变量中的英文字母，应全部小写

---

七、运算符

1、算术运算符

（1）基本介绍

运算符	描述	实例
+	两数相加	10 + 20 输出结果为 30
-	得到负数或两数相减	10 - 20 输出结果为 -10
*	两数相乘或是返回一个被重复若干次的字符串	10 * 20 输出结果为 200
/	两数相除	10 / 20 输出结果为 0.5
//	两数相除并返回商的整数部分	9 // 2 输出结果为 4
%	两数相除并余数	10 % 5 输出结果为 0
**	幂运算	10 ** 2 表示 10 的 2 次方， 输出结果为 100

（2）基本使用

print("10 + 20 输出结果为", 10 + 20)
print("10 - 20 输出结果为", 10 - 20)
print("10 * 20 输出结果为", 10 * 20)
print("10 / 20 输出结果为", 10 / 20)
print("9 // 2 输出结果为", 9 // 2)
print("10 % 5 输出结果为", 10 % 2)
print("10 ** 2 输出结果为", 10 ** 2)

• 输出结果

10 + 20 输出结果为 30
10 - 20 输出结果为 -10
10 * 20 输出结果为 200
10 / 20 输出结果为 0.5
9 // 2 输出结果为 4
10 % 5 输出结果为 0
10 ** 2 输出结果为 100

2、赋值运算符

（1）基本介绍

运算符	描述	实例
=	赋值运算符，把等号右边的结果赋给左边的变量	num = 1 + 2 * 3，num = 7
+=	加法赋值运算符	c += a 等效于 c = c + a
-=	减法赋值运算符	c -= a 等效于 c = c - a
*=	乘法赋值运算符	c *= a 等效于 c = c * a
/=	除法赋值运算符	c /= a 等效于 c = c / a
%=	取模赋值运算符	c %= a 等效于 c = c % a
//=	取整除赋值运算符	c //= a 等效于 c = c // a
**=	幂赋值运算符	c **= a 等效于 c = c ** a

（2）基本使用

num = 10
num += 5
print("num += 1 输出结果为", num)

num = 10
num -= 5
print("num -= 5 输出结果为", num)

num = 10
num *= 5
print("num *= 5 输出结果为", num)

num = 10
num /= 5
print("num /= 5 输出结果为", num)

num = 10
num %= 4
print("num %= 4 输出结果为", num)

num = 10
num //= 3
print("num //= 3 输出结果为", num)

num = 10
num **= 2
print("num **= 2 输出结果为", num)

• 输出结果

num += 1 输出结果为 15
num -= 5 输出结果为 5
num *= 5 输出结果为 50
num /= 5 输出结果为 2.0
num %= 4 输出结果为 2
num //= 3 输出结果为 3
num **= 2 输出结果为 100

---

八、字符串扩展

1、字符串定义

（1）定义格式

• 双引号定义法

"【字符串】"

• 单引号定义法

'【字符串】'

• 三个双引号定义法

"""【字符串】"""

• 注：三个双引号定义法，在三个双引号范围内，均是字符串

text = """【字符串】
    【字符串】
"""

• 三个单引号定义法

'''【字符串】'''

• 注：三个单引号定义法，在三个双引号范围内，均是字符串

text = '''【字符串】
    【字符串】
'''

（2）基本使用

text1 = "Hello World1"
text2 = 'Hello World2'
text3 = """Hello World3-1
    Hello World3-2
"""
text4 = '''Hello World4-1
    Hello World4-2
'''

print(text1)
print(text2)
print(text3)
print(text4)

• 输出结果

Hello World1
Hello World2
Hello World3-1
    Hello World3-2

Hello World4-1
    Hello World4-2

2、字符串的引号嵌套

（1）基本介绍

• 单引号定义法，可以内含双引号

• 双引号定义法，可以内含单引号

• 可以使用转移字符（\）来将引号解除效用，变成普通字符串

（2）基本使用

# 在字符串内包含双引号
str1 = '"Hello World1"'
print(str1)

# 在字符串内包含单引号
str2 = "'Hello World2'"
print(str2)

# 使用转移字符（\）来将引号解除效用
str3 = "\"Hello World3\""
print(str3)

str4 = '\'Hello World4\''
print(str4)

• 输出结果

"Hello World1"
'Hello World2'
"Hello World3"
'Hello World4'

3、字符串拼接

• 字符串字面量之间的拼接

print("Hello " + "World") # Hello World

• 字符串字面量和字符串变量的拼接

name = "jack"
print("Hello " + name) # Hello jack

• 注：无法和非字符串类型进行拼接

4、字符串格式化

（1）字符串拼接的缺点

1. 变量过多，拼接起来太麻烦

2. 字符串无法和数字或其它类型完成拼接

（2）字符串格式化使用

name = "jack"
age = 20
print("我的名字是 %s" % name) # 我的名字是 jack
print("我的名字是 %s，我今年 %s 岁" % (name, age)) # 我的名字是 jack，我今年 20 岁

符号	说明
%	表示占位
s	表示将变量变成字符串放入占位位置

• 注：多个变量占位，变量要用括号括起来，并按照占位的顺序填入，使用逗号分隔

（3）常用数据类型占位

格式符号	说明
%s	将内容转换成字符串，放入占位位置
%d	将内容转换成整数，放入占位位置
%f	将内容转换成浮点数，放入占位位置

• 基本使用

name = "smith"
age = 15
score = 90.5
print("我的名字是 %s，我今年 %d 岁，我的成绩是 %f" % (name, age, score)) # 我的名字是 smith，我今年 15 岁，我的成绩是 90.500000

5、字符串格式化数字精度控制

（1）基本介绍

• 使用辅助符号“m.n”来控制数据的宽度和精度

符号	说明
m	控制宽度，要求是数字（很少使用），当设置的宽度小于数字自身时，不生效
.n	控制小数点精度，要求是数字，会进行小数的四舍五入

示例	说明
%5d	表示将宽度设置为 5 位 如，对数字 11 设置 %5d，结果是：【空格】【空格】【空格】11，3 个空格补足宽度
%5.2f	表示将宽度设置为 5 位，将小数点精度设置为 2 位，小数点和小数部分也加入宽度计算 如，对数字 11.345 设置 %7.2f，结果是：【空格】【空格】11.35，2 个空格补足宽度，小数部分四舍五入为 .35
%.2f	表示不限制宽度，只将小数点精度设置为 2 位 如，对数字 11.345 设置 %.2f，结果是：11.35

（2）基本使用

num1 = 11
num2 = 12.345

print("数字 11 宽度设置为 5，结果是：%5d" % num1)
print("数字 11 宽度设置为 1，结果是：%1d" % num1)
print("数字 12.345 宽度设置为 7，小数精度设置为 2，结果是：%7.2f" % num2)
print("数字 12.345 不限制宽度，小数精度设置为 2，结果是：%0.2f" % num2)

• 输出结果

数字 11 宽度设置为 5，结果是：   11
数字 11 宽度设置为 1，结果是：11
数字 12.345 宽度设置为 7，小数精度设置为 2，结果是：  12.35
数字 12.345 不限制宽度，小数精度设置为 2，结果是：12.35

6、字符串快速格式化

（1）基本介绍

f"{【变量】}"

• 注：这种写法不做精度控制，也不理会类型，适用于快速格式化字符串

（2）基本使用

name = "tom"
age = 15
score = 90.5
print(f"我的名字是 {name}，我今年 {age} 岁，我的成绩是 {score}")

• 输出结果

我的名字是 tom，我今年 15 岁，我的成绩是 90.5

7、表达式格式化

（1）什么是表达式

• 表达式是一条具有明确执行结果的代码语句

• 如：1 + 1、5 * 2 就是表达式，因为有具体的结果，结果是一个数字

• 又或者，常见的变量定义：name = “张三”、age = 11 + 11，等号右侧的都是表达式，因为它们有具体的结果，结果赋值给了等号左侧的变量

（2）表达式格式化使用

print("2 * 3 的结果是：%d" % (2 * 3))
print(f"3 * 4 的结果是：{3 * 4}")
print("'Hello World' 在 Python 中的类型是：%s" % type('Hello World'))

• 输出结果

2 * 3 的结果是：6
3 * 4 的结果是：12
'Hello World' 在 Python 中的类型是：<class 'str'>

---

九、键盘输入

1、input() 语句

• print() 语句可以完成将内容（字面量、变量等）输出到屏幕上，在 Python 中，与之对应的还有一个 input() 语句，用来获取键盘输入

• 使用 input() 语句可以从键盘获取输入,使用一个变量接收 input() 语句获取的键盘输入数据即可

• 可以通过使用 input(【提示信息】) 用以在使用者输入内容之前显示提示信息

• 无论键盘输入什么类型的数据，获取到的数据永远都是字符串类型

2、基本使用

# 输入字符串类型
print("请告诉我你的名字：")
name = input()
print("你的名字是", name)

print("------------------------------")

# 输入数字类型
age_str = input("请告诉我你的年龄：")
print(f"你输入的年龄是：{age_str}，类型是：{type(age_str)}")
age = int(age_str)
print("你的年龄现在类型是：", type(age))

• 输出结果

请告诉我你的名字：
jack
你的名字是 jack
------------------------------
请告诉我你的年龄：20
你输入的年龄是：20，类型是：<class 'str'>
你的年龄现在类型是： <class 'int'>