目录

变量

变量的使用

变量命名规范

基本语法

注释

语句分隔符

缩进

Python编码规范（PEP 8）

输入输出函数

基本数据类型

整型和浮点型

布尔类型

字符串

字符串转义符

长字符串

格式化字符串

序列类型操作

内置方法

类型转换

运算符

算数运算符

赋值运算符

比较运算符

逻辑运算符

附录

---

变量

变量的使用

变量是一段有名字的连续存储空间。我们通过定义变量来申请并命名这样的存储空间，并通过变量的名字来使用这段存储空间。在编程语言中，将数据放入变量的过程叫做赋值（Assignment）。Python 使用等号=作为赋值运算符，具体格式为：

变量名 = 任意类型的值

x  = 10
y  = "hello,yuan"
z  = True
x  = 20

python作为动态语言的代表，是不同于C语言等静态语言的变量存储原理的

x = 10
print(id(x))
x = 20  # 内存变化
print(id(x))

变量命名规范

简单地理解，标识符就是一个名字，就好像我们每个人都有属于自己的名字，它的主要作用就是作为变量、函数、类、模块以及其他对象的名称。Python中标识符的命名不是随意的，而是要遵守一定的命令规则

• 标识符是由字符（A~Z 和 a~z）、下划线和数字组成，但第一个字符不能是数字。

• 标识符不能和 Python 中的保留字相同。有关保留字，后续章节会详细介绍。

• Python中的标识符中，不能包含空格、@、% 以及 $ 等特殊字符。

• 在 Python 中，标识符中的字母是严格区分大小写

• Python 允许使用汉字作为标识符（不推荐）

基本语法

注释

注释就是对代码的解释和说明，其目的是让人们能够更加轻松地了解代码。注释是编写程序时，写程序的人给一个语句、程序段、函数等的解释或提示，能提高程序代码的可读性。一般情况下，合理的代码注释应该占源代码的 1/3 左右。

注释只是为了提高公认阅读，不会被解释器执行。

Python 支持两种类型的注释，分别是单行注释和多行注释。

#  单行注释
"""
这是一个多行注释
三引号里面的任何内容不会被解释器执行
"""

语句分隔符

就像我们写作文一样，逗号、句号等语句分隔符是非常重要的，程序也一样，要想让解释器能读懂，语句和语句之间一定要有分隔符。在C、Java等语言的语法中规定，必须以分号作为语句结束的标识。Python也支持分号，同样用于一条语句的结束标识。但在Python中分号的作用已经不像C、Java中那么重要了，Python中的分号可以省略，主要通过换行来识别语句的结束。

缩进

和其它程序设计语言（如 Java、C 语言）采用大括号“{}”分隔代码块不同，Python 采用冒号（ : ）和代码缩进和来区分代码块之间的层次。在 Python 中，对于类定义、函数定义、流程控制语句、异常处理语句等，行尾的冒号和下一行的缩进，表示下一个代码块的开始，而缩进的结束则表示此代码块的结束。

注意，Python 中实现对代码的缩进，可以使用空格或者 Tab 键实现。但无论是手动敲空格，还是使用 Tab 键，通常情况下都是采用 4 个空格长度作为一个缩进量（默认情况下，一个 Tab 键就表示 4 个空格）。

Python编码规范（PEP 8）

Python 采用 PEP 8 作为编码规范，其中 PEP 是 Python Enhancement Proposal（Python 增强建议书）的缩写，8 代表的是 Python 代码的样式指南。下面仅给大家列出 PEP 8 中初学者应严格遵守的一些编码规则：

1、不要在行尾添加分号，也不要用分号将两条命令放在同一行

2、通常情况下，在运算符两侧、函数参数之间以及逗号两侧，都建议使用空格进行分隔。

3、使用必要的空行可以增加代码的可读性，通常在顶级定义（如函数或类的定义）之间空两行，而方法定义之间空一行，另外在用于分隔某些功能的位置也可以空一行。

输入输出函数

print函数 ： 用于打印输出，是python中最常见的一个函数。

def print(self, *args, sep=' ', end='\n', file=None): # known special case of print
    """
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
    
    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file:  a file-like object (stream); defaults to the current sys.stdout.
    sep:   string inserted between values, default a space.
    end:   string appended after the last value, default a newline.
    flush: whether to forcibly flush the stream.
    """
    pass

input函数：用于读入一个字符串的函数

以上信息说明input函数在python中是一个内建函数，其从标准输入中读入一个字符串，并自动忽略换行符。也就是说所有形式的输入按字符串处理，如果想要得到其他类型的数据进行强制类型转化。

name = input("您的姓名：")
age = input("您的年龄：")
print(name,type(name))
print(age,type(age))

基本数据类型

整型和浮点型

在python中整数都属于整型，不同于C语言会根据整数的大小将整型分类为short、int、long、long long 四种类型，python只有一种整型，即int类型，无论整型数字多大多小都属于int。

x = 10
print(type(x))  # <class 'int'>

在python中小数都属于浮点型(float）,有两种表现形式

# 小数点形式
f =  3.14
print(f)  # 3.14
print(type(f)) # <class 'float'>

布尔类型

布尔型（Boolean）是一种数据的类型，这种类型只有两种值，即"真"与"假"。在python中用 bool表示布尔类型，"真"用关键字true表示，"假"用false表示。

print(4 == 2) # False
print(5 > 1)  # True

name = "yuan"
print(name == "alvin") # False
print(1 == "1") # False

不光表达式的结果是布尔值，任意值都有自己的布尔值，这就涉及到布尔的零值。

# 任意数据类型都一个具体值的布尔值为False,我们称为零值。该类型的其他值的布尔值皆为True。
print(bool("")) # 字符串的零值 “”
print(bool(0))  # 整型的零值 0
print(bool(False)) # 布尔类型的零值 False

print(bool("0"))
print(bool("-1"))  
print(bool("yuan"))
print(bool(-1))
print(bool(0.1))

字符串

字符串是由零个或多个字符组成的有限序列。字符串的内容可以包含字母、标点、特殊符号、中文、日文等全世界的所有字符。

在python中字符串是通过单引号''或者双引号""标识的。

s1 = "hi yuan"
print(s1)

s2 = ""
print(s2)

s3 = 'yuan老师是最帅的老师!'
print(s3)

Python 字符串中的双引号和单引号没有任何区别！

字符串转义符

s1 = "hi yuan\nhi，alvin"
print(s1)

长字符串

s = """
    s = "hi yuan\\nhi，alvin"
    I'm yuan\n
    这是一个python解释器路径："D:\\nythonProject\\nenv\Scripts\python.exe" 
长字符串中放置单引号或者双引号不会导致解析错误
"""
print(s)

格式化字符串

之前讲到过 print() 函数的用法，这只是最简单最初级的形式，print() 还有很多高级的玩法，比如格式化输出。

name = "yuan"
age = 23
print("My name is %s; My age is %d" % (name, age))
print(f"My name is {name}; My age is {age}")

在 print() 函数中，由引号包围的是格式化字符串，它相当于一个字符串模板，可以放置一些转换说明符（占位符）。本例的格式化字符串中包含一个%s和%d说明符，它最终会被后面的name和age 变量的值所替代。中间的%是一个分隔符，它前面是格式化字符串，后面是要输出的表达式。

序列类型操作

字符串属于序列类型，所谓序列，指的是一块可存放多个值的连续内存空间，这些值按一定顺序排列，可通过每个值所在位置的编号（称为索引）访问它们。

s= "hello yuan"
print(len(s))

Python 还支持索引值是负数，此类索引是从右向左计数，换句话说，从最后一个元素开始计数，从索引值 -1 开始，如图 所示。

序列类型支持的操作：

# （1）索引取值
s = "hello yuan"
print(s[6])
print(s[-10])

# （2）切片取值：序列类型对象[start : end : step]
s = "hello yuan"
print(s[1:4]) # ell  ：取索引1到索引3（左闭又开）
print(s[:4])  # hell ：start缺省，默认从0取
print(s[:])  # ello yuan ： end缺省，默认取到最后
print(s[1:-1]) # ello yua

# （3）判断存在：Python 中，可以使用 in 关键字检查某元素是否为序列的成员。
s = "hello yuan"
print("yuan" in s) # True

# （4）支持两种类型相同的序列使用“+”运算符做相加操作，它会将两个序列进行连接，但不会去除重复的元素。
#     使用数字 n 乘以一个序列会生成新的序列，其内容为原来序列被重复 n 次的结果
s = "hello"+" yuan"
print(s) # hello yuan
s= "*"*10
print(s) # **********

内置方法

方法	作用	示例	输出
upper	全部大写	"hello".upper()	"HELLO"
lower	全部小写	"Hello".lower()	"hello"
startswith()	是否以a开头	"Yuan".startswith("Yu")	True
endswith()	是否以a结尾	"Yuan".endswith("a")	False
isdigit()	是否全数字	'123'.isdigit()	True
strip()	去两边空格	" hi yuan \n".strip()	"hi yuan"
join()	将多个字符串连接在一起	"-".join(["yuan","alvin","eric"])	"yuan-alvin-eric"
split()	按某字符分割字符串，默认按空格分隔	"yuan-alvin-eric".split("-")	['yuan', 'alvin', 'eric']
find()	搜索指定字符串，没有返回-1	"hello world".index("w")	6
index()	同上，但是找不到会报错	"hello world".index("w")	6
count()	统计指定的字符串出现的次数	"hello world".count("l")	3
replace()	替换old为new	'hello world'.replace(‘world',‘python')	"hello python"

# 任意数据对象.方法()实现对数据的某种操作
# 不同数据类型对象支持不同方法
# 字符串类型对象支持哪些方法

s1 = "yuan"
s2 = "RAIN"
# (1) upper方法和lower方法
s3 = s1.upper()
s4 = s2.lower()
print(s3) # "YUAN"
print(s4) # "rain"


s5 = "hello yuan"
s6 = "hi world"
# (2) startswith和endswith：判断字符串是否以什么开头和结尾
print(s5.startswith("hello")) # True
print(s6.startswith("hello")) # False
print(s6.startswith("hi wor")) # True
print(s6.endswith("hi wor")) # False

# (3) isdigit(): 判断字符串是否是一个数字字符串
s7 = "123"
s8 = "123A"
print(s7.isdigit()) # True
print(s8.isdigit()) # False
s9 = "123SAA%#"
print(s9.isalnum()) # False 不能包含特殊符号

# (4) strip(): 去除两端空格和换行符号

s10 = " I am yuan "
print(s10)
print(s10.strip())
name = input("请输入姓名>>").strip()
print(name)

# (5) split分割方法: 将一个字符串分割成一个列表
s11 = "rain-yuan-alvin-eric"
print(s11.split("-")) # ['rain', 'yuan', 'alvin', 'eric']

# (6) join方法: 将一个列表中的字符串拼接成一个字符串
names_list = ['rain', 'yuan', 'alvin', 'eric']
s12 = "-".join(names_list) # 用什么分隔符拼接names_list列表
print(s12,type(s12)) # "rain-yuan-alvin-eric"

类型转换

i = int("3")
print(i,type(i)) # 3 <class 'int'>

s = str(3.14)
print(s,type(s)) # 3.14 <class 'str'>

运算符

算数运算符

运算符	说明	实例	结果
+	加	1+1	2
-	减	1-1	0
*	乘	1*3	3
/	除法（和数学中的规则一样）	4/2	2
//	整除（只保留商的整数部分）	7 // 2	3
%	取余，即返回除法的余数	7 % 2	1
**	幂运算/次方运算，即返回 x 的 y 次方	2 ** 4	16，即 24

赋值运算符

运算符	说 明	用法举例	等价形式
=	最基本的赋值运算	x = y	x = y
+=	加赋值	x += y	x = x + y
-=	减赋值	x -= y	x = x - y
*=	乘赋值	x *= y	x = x * y
/=	除赋值	x /= y	x = x / y
%=	取余数赋值	x %= y	x = x % y
**=	幂赋值	x **= y	x = x ** y
//=	取整数赋值	x //= y	x = x // y
&=	按位与赋值	x &= y	x = x & y
|=	按位或赋值	x |= y	x = x | y
^=	按位异或赋值	x ^= y	x = x ^ y
<<=	左移赋值	x <<= y	x = x << y，这里的 y 指的是左移的位数
>>=	右移赋值	x >>= y	x = x >> y，这里的 y 指的是右移的位数

比较运算符

比较运算符	说明
>	大于，如果>前面的值大于后面的值，则返回 True，否则返回 False。
<	小于，如果<前面的值小于后面的值，则返回 True，否则返回 False。
==	等于，如果==两边的值相等，则返回 True，否则返回 False。
>=	大于等于（等价于数学中的 ≥），如果>=前面的值大于或者等于后面的值，则返回 True，否则返回 False。
<=	小于等于（等价于数学中的 ≤），如果<=前面的值小于或者等于后面的值，则返回 True，否则返回 False。
!=	不等于（等价于数学中的 ≠），如果!=两边的值不相等，则返回 True，否则返回 False。
is	判断两个变量所引用的对象是否相同，如果相同则返回 True，否则返回 False。
is not	判断两个变量所引用的对象是否不相同，如果不相同则返回 True，否则返回 False。

逻辑运算符

逻辑运算符	含义	基本格式	说明
and	逻辑与运算	a and b	当 a 和 b 两个表达式都为真时，a and b 的结果才为真，否则为假。
or	逻辑或运算	a or b	当 a 和 b 两个表达式都为假时，a or b 的结果才是假，否则为真。
not	逻辑非运算	not a	如果 a 为真，那么 not a 的结果为假；如果 a 为假，那么 not a 的结果为真。相当于对 a 取反。

附录

hello.py

print("hello world2")

变量.py

x = 1
print(id(x))
y = 2
x = 10
print(id(x))   # id()函数获取变量x的内存地址
print(x)

print(1 + 2)
print(1 - 2)
print(x + y)
print(x - y)
print(x * y)
print(x / y)

print(x + y)

z = x + y
print(z)
print(z * 10)
print(z * 100)

# 变量命名
name = "yuan"
age = 18
print(name, age)

Python基本语法1

# 将姓名字符串yuan赋值操作给变量name
name = "yuan"
# 将数字18赋值给变量age
age = 18
"""
这是一个多行注释
三引号里面的任何内容不会被解释器执行
"""

Python基本语法2

# python一般都是以换行符作为语句分隔符
a = 1
b = 2

整型与浮点型

x = -100
x = 100

# type()函数获取y的类型
print(type(x))  # <class 'int'>

y = 3.14
print(type(y))  # <class 'float'>

布尔.py

# 整型：1，2，3，4, ... 100000000
# 浮点型：1.1,1.2,1.3,...
# 布尔类型： True  False

# x = 2 > 1
# print(x)
# print(type(x))  # <class 'bool'>
#
# y = 2 == 3
# print(y)
# print(type(y))  # <class 'bool'>

# 拓展一下：零值:每一个数据类型都有一个布尔值为Fasle的值
print(2 > 1)
print(bool(2 > 1))
print(bool(2 != 1))

# 整型的唯一零值是0
print(bool(1))
print(bool(-1))
print(bool(-100))
print(bool(0))
# 字符串的唯一零值是""
print(bool("0"))
print(bool("-1"))
print(bool("False"))
print(bool("false"))
print(bool(""))

# 列表的零值 []
# 字典的零值 {}
if "假的":
    print("OK")

字符串类型.py

name = "yuan"  # 标识字符串可以用双引号，也可以用单引号
name = 'rain'
print(name)

# 一 字符串的转义符号：\
# 转义符号：\的功能有两个：
# （1）赋予一些普通符号以特殊功能
# （2）取消一些特殊符号的特殊功能变为普通符号
#  \n:换行符
print("hello world\nhello yuan")

print('i\' m yuan')   # 打印出字符 '

print("hello world\\nhello yuan")   # 打印出字符 \

# 二 长字符串
s = """ssssssssssssssssssss
AAAAAAAAAAAAAAA
       BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"""
print(s)

# 三 格式化输出

name = "alvin"
age = 22
height = 190

print("我的姓名：%s，我的年龄：%s，我的身高：%s" % (name, age, height))  # 模板
print(f"我的姓名：{name}，我的年龄：{age}，我的身高：{height}")

# 四： 序列类型操作

s = "hello yuan"
# 索引操作 ：获取一个字符 字符串[索引]
print(s[8])
print(s[-2])
# 切片操作：获取一段字符串  字符串[开始索引:结束索引:步长=1]
print(s[6:9])  # yua
print(s[6:-1])  # yua
print(s[6:])  # yuan
print(s[0:5])  # hello
print(s[:5])  # hello
print(s[:])  # hello yuan
print(s[::-1])  # 字符串的翻转：hello yuan

# 五 in 操作：判断是否存在

print("yuan" in s)  # 返回布尔值
print("yuan " in s)  # 返回布尔值

# 六： + 拼接
a = "hello "
b = "yuan"
print(a + b)

字符串内置方法.py

# 类型对象.该类型对象拥有的方法

s1 = "Hello World"
s2 = "rain"
# new_s1 = s1.upper()
# new_s2 = s2.upper()
print(s1.upper())     # 字符串的upper()方法来将s1中的所有字符转换为大写。
print(s1.lower())     # 字符串的lower()方法来将s1中的所有字符转换为小写。
print(s1.startswith("H"))  # 返回布尔值    字符串的startswith()方法来检查s1是否以指定的前缀开头。
print(s1.startswith("He"))  # 返回布尔值
print(s1.startswith("Hel"))  # 返回布尔值
print(s1.startswith("World"))  # 返回布尔值
print(s1.startswith("ell"))  # 返回布尔值
print(s1.startswith("h"))  # 返回布尔值
print(s1.endswith("World"))
print(s1.endswith("ld"))

print(s1.replace("World", "Yuan"))   # 字符串的replace()方法来将字符串中的特定子字符串替换为新的子字符串
print(s1)

num = "100"  # 数字字符串
print(num.isdigit())  # isdigit()方法是字符串对象的一个方法，它用于检查字符串是否只包含数字字符。如果字符串中的所有字符都是数字字符，则返回True，否则返回False。

word = "   hello world   "
print(word)
print(len(word))
print(word.strip())    # strip()是字符串对象的一个方法，用于去除字符串两端的空白字符。

# 最重要的两个方法： split join

# 字符串的split()方法来将字符串按照指定的分隔符进行拆分
s = "北京 上海 深圳 广州"
cities = s.split(" ")  # ['北京', '上海', '深圳', '广州']

print(cities[1])
print(cities[3])
print(len(cities))
print(cities)
# join()是字符串对象的一个方法，它将指定的可迭代对象中的元素连接成一个字符串，并使用调用该方法的字符串作为连接符。
print(",".join(cities))  # "北京,上海,深圳,广州"

# index()方法：查索引
s1 = "Hello World"
print(s1.index("W"))
print(s1.index("o", 5, 10))
print(s1.index("World"))

类型转换.py

x = 100  # int
y = str(x)  # 将整型转换为字符串
print(type(y))  # <class 'str'>

a = "100"
b = int(a)
print(type(b))  # int