1. 基本概念

1.1 表达式

表达式就是一个类似于数学公式的东西

比如：10 + 5   8 - 4
表达式一般仅仅用了计算一些结果，不会对程序产生实质性的影响
如果在交互模式中输入一个表达式，解释器会自动将表达式的结果输出

1.2 语句

在程序中语句一般需要完成某种功能，比如打印信息、获取信息、为变量赋值。。。
比如：
        print()
        input()
        a = 10
语句的执行一般会对程序产生一定的影响
在交互模式中不一定会输出语句的执行结果  

1.3 程序（program）

程序就是由一条一条的语句和一条一条的表达式构成的。

1.4 函数（function）

函数就是一种语句，函数专门用来完成特定的功能
函数长的形如：xxx()          
函数的分类：
   内置函数
        - 由Python解释器提供的函数，可以在Python中直接使用
   自定义函数   
         - 由程序员自主的创建的函数
当我们需要完成某个功能时，就可以去调用内置函数，或者自定义函数
函数的两个要素：
    参数
        - ()中的内容就是函数的参数
        - 函数中可以没有参数，也可以有多个参数，多个参数之间使用,隔开
    返回值        
        - 返回值是函数的返回结果，不是所有的函数都有返回值

2. 基本语法

1.在Python中严格区分大小写
2.Python中的每一行就是一条语句，每条语句以换行结束
3.Python中每一行语句不要过长（规范中建议每行不要超过80个字符）
    "rulers":[80],
4.一条语句可以分多行编写，多行编写时语句后边以\结尾  
5.Python是缩进严格的语言，所以在Python中不要随便写缩进  
6.在Python中使用#来表示注释，#后的内容都属于注释，注释的内容将会被解释器所忽略
    我们可以通过注释来对程序进行解释说明，一定要养成良好的编写注释的习惯
    注释要求简单明了，一般习惯上#后边会跟着一个空格

示例：

print('hello','哈哈','abc')
print(123)
print('bcd')

a = 20
print(a)

执行结果：

hello 哈哈 abc
123
bcd
20
[Finished in 58ms]

3. 变量和标识符

数据类型

数据类型指的就是变量的值得类型，也就是可以为变量赋哪些值

• 整数（int）：表示整数值，如 1, 2, -3。
• 浮点数（float）：表示带有小数点的数值，如 3.14, -2.5。
• 字符串（str）：表示文本数据，用引号（单引号或双引号）括起来，如 "Hello, World!"。
• 布尔值（bool）：表示逻辑值，只有两个取值 True 和 False。
• 复数（complex）：表示具有实部和虚部的复数，如 3+2j, -1-4j。
• 空值（None）：表示空值或缺失值的特殊对象，通常用于表示变量的初始状态或函数的返回值。

变量示例：

# Python中使用变量，不需要声明，直接为变量赋值即可
a = 10

# 不能使用没有进行过赋值的变量
# 如果使用没有赋值过的变量，会报错 NameError: name 'b' is not defined
# print(b)

# Python是一个动态类型的语言，可以为变量赋任意类型的值，也可以任意修改变量的值
a = 'hello'

# print(a)

# 标识符
# 在Python中所有可以自主命名的内容都属于标识符
# 比如：变量名、函数名、类名
# 标识符必须遵循标识符的规范
#   1.标识符中可以含有字母、数字、_，但是不能使用数字开头
#       例子：a_1 _a1 _1a
#   2.标识符不能是Python中的关键字和保留字
#       也不建议使用Python中的函数名作为标识符,因为这样会导致函数被覆盖
#   3.命名规范：
#       在Python中注意遵循两种命名规范：
#           下划线命名法
#               所有字母小写，单词之间使用_分割
#               max_length min_length hello_world xxx_yyy_zzz
#           帕斯卡命名法（大驼峰命名法）  
#               首字母大写，每个单词开头字母大写，其余字母小写
#               MaxLength MinLength HelloWorld XxxYyyZzz  
#       
#   如果使用不符合标准的标识符，将会报错 SyntaxError: invalid syntax    
#   练习：尝试自己定义几个变量（复杂一些，尝试不同的命名法），然后打印一些变量
#           通过搜索引擎搜索还有哪些其他的命名规范
_b123 = 20
# print(_b123)

# print = 123
# print(print)

数值示例：

# 在Python数值分成了三种：整数、浮点数（小数）、复数
# 在Python中所有的整数都是int类型
a = 10
b = 20
# Python中的整数的大小没有限制，可以是一个无限大的整数
# c = 999999999999999999999999999999999999999999999 ** 100

# 如果数字的长度过大，可以使用下划线作为分隔符
c = 123_456_789

# d = 0123 10进制的数字不能以0开头
# 其他进制的整数，只要是数字打印时一定是以十进制的形式显示的
# 二进制 0b开头
c = 0b10 # 二进制的10
# 八进制 0o开头
c = 0o10
# 十六进制 0x开头
c = 0x10

# 也可以通过运算符来对数字进行运算，并且可以保证整数运算的精确
c = -100
c = c + 3

# 浮点数（小数），在Python中所有的小数都是float类型
c = 1.23
c = 4.56

# 对浮点数进行运算时，可能会得到一个不精确的结果
c = 0.1 + 0.2 # 0.30000000000000004

print(c)

字符串示例：

# 字符串(str)
# 字符串用来表示一段文本信息，字符串是程序中使用的最多的数据类型
# 在Python中字符串需要使用引号引起来

s = 'hello'
# s = abc # 字符串必须使用引号引起来，不使用不是字符串
# 引号可以是双引号，也可以是单引号，但是注意不要混着用
s = 'hello'
s = "hello"
# s = 'hello" 引号不能混合使用  SyntaxError: EOL while scanning string literal

# 相同的引号之间不能嵌套
# s = "子曰:"学而时习之，乐呵乐呵！""
s = '子曰:"学而时习之，乐呵乐呵！"'

# 长字符串
# 单引号和双引号不能跨行使用
s = '锄禾日当午，\
汗滴禾下土，\
谁知盘中餐，\
粒粒皆辛苦'

# 使用三重引号来表示一个长字符串 ''' """
# 三重引号可以换行，并且会保留字符串中的格式

s = '''锄禾日当午，
汗滴禾下土，
谁知盘中餐，
粒粒皆辛苦'''

# 转义字符
# 可以使用 \ 作为转义字符，通过转义字符，可以在字符串中使用一些特殊的内容
# 例子：
#   \' 表示'
#   \" 表示"
#   \t 表示制表符
#   \n 表示换行符
#   \\ 表示反斜杠
#   \uxxxx 表示Unicode编码
s = "子曰:\"学而时习之，\\\\n乐呵乐呵！\""

s = '\u2250'
print(s)

格式化字符串示例：

# 格式化字符串
a = 'hello'

# 字符串之间也可以进行加法运算
# 如果将两个字符串进行相加，则会自动将两个字符串拼接为一个
a = 'abc' + 'haha' + '哈哈'
# a = 123 
# 字符串只能不能和其他的类型进行加法运算，如果做了会出现异常 TypeError: must be str, not int
# print("a = "+a) # 这种写法在Python中不常见
a = 123
# print('a =',a)

# 在创建字符串时，可以在字符串中指定占位符
# %s 在字符串中表示任意字符
# %f 浮点数占位符
# %d 整数占位符
b = 'Hello %s'%'孙悟空'
b = 'hello %s 你好 %s'%('tom','孙悟空')
b = 'hello %3.5s'%'abcdefg' # %3.5s字符串的长度限制在3-5之间
b = 'hello %s'%123.456
b = 'hello %.2f'%123.456
b = 'hello %d'%123.95
b = '呵呵'

# print('a = %s'%a)

# 格式化字符串，可以通过在字符串前添加一个f来创建一个格式化字符串
# 在格式化字符串中可以直接嵌入变量
c = f'hello {a} {b}'

print(f'a = {a}')

# 练习 创建一个变量保存你的名字，然后通过四种格式化字符串的方式
#   在命令行中显示，欢迎 xxx 光临！

复制字符串示例：

# 字符串的复制（将字符串和数字相乘）
a = 'abc'
# * 在语言中表示乘法
# 如果将字符串和数字相乘，则解释器会将字符串重复指定的次数并返回
a = a * 20

print(a)

布尔值示例：

# 布尔值（bool）
# 布尔值主要用来做逻辑判断
# 布尔值一共有两个 True 和 False
# True表示真 False表示假
a = True
a = False
# print('a =',a)

# 布尔值实际上也属于整型，True就相当于1，False就相当于0
# print(1 + False)

# None（空值）
# None专门用来表示不存在
b = None
print(b)

4. 类型检查

# 通过类型检查，可以检查只能值（变量）的类型

a = 123 # 数值
b = '123' # 字符串

# print('a =',a)
# print('b =',b)、

# type()用来检查值的类型
# 该函数会将检查的结果作为返回值返回，可以通过变量来接收函数的返回值
c = type('123')
c = type(a)
# print(type(b))
print(type(1)) # <class 'int'>
print(type(1.5)) # <class 'float'>
print(type(True)) # <class 'bool'>
print(type('hello'))  # <class 'str'>
print(type(None)) # <class 'NoneType'>

5. 对象

5.1 对象（Object）

在Python中，一切都是对象。对象是Python编程语言中的核心概念之一，它是数据和操作的封装。每个对象都有一个类型（type），它决定了对象可以执行的操作以及如何处理对象。

以下是关于Python对象的简单介绍：

• 对象特征：每个对象都有特定的状态（attributes）和行为（methods）。状态是对象的数据，可以通过属性访问和修改。行为是对象的操作，可以通过方法调用来执行。

• 对象的创建：使用类（class）来创建对象。类是对象的蓝图，定义了对象的属性和方法。通过类的实例化操作，可以创建具体的对象。

• 对象的属性：属性是对象的状态信息，用于存储数据。可以通过点符号（.）访问对象的属性。例如，对于字符串对象，可以访问其长度属性 len(string)。

• 对象的方法：方法是对象的行为，用于执行特定的操作。方法是与对象绑定的函数，通过对象调用。例如，对于字符串对象，可以调用其方法 string.upper() 将字符串转换为大写。

• 对象的身份：每个对象都有唯一的身份标识，可以通过 id(object) 函数获得。身份标识是对象在内存中的地址，用于区分不同的对象。

• 对象的类型：对象的类型决定了对象可以执行的操作。可以使用 type(object) 函数获取对象的类型。例如，对于整数对象，其类型为 int；对于字符串对象，其类型为 str。

• 对象的可变性：某些对象是可变的（mutable），可以修改其状态；而某些对象是不可变的（immutable），其状态不可改变。例如，列表对象是可变的，可以添加、删除或修改元素；而字符串对象是不可变的，无法修改其字符。

• 对象的比较：对象之间可以进行比较操作，比较运算符如等于（==）、不等于（!=）、大于（>）、小于（<）、大于等于（>=）、小于等于（<=）用于比较对象的值。但需要注意，对于不同类型的对象，比较操作的结果可能是不确定的。

• 对象的销毁：Python有自动的垃圾回收机制，用于回收不再使用的对象的内存空间。当对象不再被引用时，垃圾回收机制将自动销毁对象，并释放其占用的内存。

• 对象的继承和多态：Python支持继承和多态的面向对象特性。继承允许一个类继承另一个类的属性和方法，从而实现代码的重用和扩展。多态性允许不同类的对象对相同的方法进行不同的实现，提供了更大的灵活性和可扩展性。

• 对象的序列化和反序列化：通过序列化，可以将对象转换为字节流或文本，用于存储或传输。反序列化则是将序列化的对象重新恢复为原始对象。Python提供了模块如pickle和json来支持对象的序列化和反序列化操作。

• 内置对象和自定义对象：Python提供了许多内置对象，如整数、字符串、列表、字典等，可以直接使用。同时，你也可以创建自定义对象，根据自己的需求定义属性和方法，以及实现特定的行为。

Python中的对象机制使得代码具有灵活性和可扩展性。你可以创建自定义的对象，定义自己的属性和方法，以及实现自己的逻辑。通过使用对象，可以更好地组织和管理代码，并实现面向对象编程的思想。

5.2 对象的结构

在Python中，每个对象都具有内部结构，其中包括对象的标识符（id）、类型（type）和值（value）。

• 标识符（id）：每个对象都有一个唯一的标识符，用于标识对象在内存中的地址。可以使用内置函数 id(object) 来获取对象的标识符。标识符在对象的生命周期中保持不变，即使对象的值发生变化。

• 类型（type）：对象的类型决定了对象可以执行的操作和具备的特性。可以使用内置函数 type(object) 来获取对象的类型。类型定义了对象的属性和方法，并决定了对象在内存中的布局和行为。

• 值（value）：对象的值是对象所包含的实际数据。不同类型的对象具有不同的值。例如，整数对象的值可以是整数数值，字符串对象的值可以是字符串文本，列表对象的值可以是一组元素等。

除了标识符、类型和值之外，对象还可以具有其他属性和方法，这取决于对象所属的类和其定义。这些属性和方法可以让我们对对象进行操作、访问和修改。

需要注意的是，Python中的对象是动态的，意味着对象的类型和值可以在运行时进行改变。这使得Python非常灵活，可以根据需要动态地创建和修改对象。

总结起来，Python对象的结构包括标识符（id）、类型（type）、值（value），以及对象所具有的属性和方法。这些元素共同构成了对象在内存中的表示和行为。

6 变量和对象

对象并没有直接存储到变量中，在Python中变量更像是给对象起了一个别名。变量中存储的不是对象的值，而是对象的id（内存地址），当我们使用变量时，实际上就是在通过对象id在查找对象
变量中保存的对象，只有在为变量重新赋值时才会改变。
变量和变量之间是相互独立的，修改一个变量不会影响另一个变量。

7 类型转换

所谓的类型转换，将一个类型的对象转换为其他对象
类型转换不是改变对象本身的类型，而是根据当前对象的值创建一个新对象

# 类型转换四个函数 int() float() str() bool()
# int() 可以用来将其他的对象转换为整型
# 规则：
#   布尔值：True -> 1   False -> 0
#   浮点数：直接取整，省略小数点后的内容
#   字符串：合法的整数字符串，直接转换为对应的数字
#           如果不是一个合法的整数字符串，则报错 ValueError: invalid literal for int() with base 10: '11.5'
#   对于其他不可转换为整型的对象，直接抛出异常 ValueError
# float() 和 int()基本一致，不同的是它会将对象转换为浮点数
# str() 可以将对象转换为字符串
#  True -> 'True'
#  False -> 'False'
#  123 -> '123' 
#  。。。
#  bool() 可以将对象转换为布尔值，任何对象都可以转换为布尔值
#   规则：对于所有表示空性的对象都会转换为False，其余的转换为True
#       哪些表示的空性：0 、 None 、 '' 。。。

a = True

# 调用int()来将a转换为整型
# int()函数不会对原来的变量产生影响，他是对象转换为指定的类型并将其作为返回值返回
# 如果希望修改原来的变量，则需要对变量进行重新赋值
a = int(a)

a = False
a = int(a)

a = '123'
a = int(a)

a = 11.6
a = int(a)

a = '11.5'
# a = int(a)

a = None
# a = int(a)

a = 1
a = float(a)

a = False
a = float(a)

a = 123
a = str(a)

a = None
a = bool(a)

print('a =',a)
print('a的类型是',type(a))
# b = 456
# print('hello'+str(b))