注释

单行注释：

# 这是一条注释信息

多行注释：

'''
这是多行注释
'''

"""
这是多行注释
"""

变量

什么是变量？

变量就是把某些值或者运行的结果临时保存在内存中，以便后续调用

强类型与弱类型

强类型（Strongly Typed）

• 定义：在强类型语言中，类型检查在编译时或运行时都很严格，变量的类型在定义时明确，且不允许隐式转换。
• 特征：
  • 不同类型之间的操作会导致错误。
  • 类型安全，高度限制了类型不兼容的操作。
• 示例语言：Java、C++、Python、Rust

示例：python

a = 10
b = "10"
print(a+b)
print(a == b)

# Output:
TypeError: unsupported operand type(s) for +: 'int' and 'str'
......

弱类型（Weakly Typed）

• 定义：在弱类型语言中，变量的数据类型可以在运行时发生变化，允许隐式转换。
• 特征：
  • 不同类型之间的操作可能会被自动转换。
  • 灵活性高，但可能导致运行时错误或意外结果。
• 示例语言：JavaScript、PHP、Ruby

示例：JavaScript

let a = "5";
let b = 10;
let result = a + b; // result 为 "510"（字符串拼接）

动态类型与静态类型

动态类型（Dynamically Typed）

• 定义：动态类型语言在运行时确定变量的类型，变量可以在程序执行过程中改变其类型。
• 特征：
  • 变量不需要在声明时指定类型。
  • 类型检查在运行时进行。
  • 允许在同一变量中存储不同类型的数据。
• 示例语言：JavaScript、Python、Ruby、PHP。

示例：python

a = 10      # 整数类型
print(a)    # 输出: 10

a = "Hello" # 现在是字符串类型
print(a)    # 输出: Hello

静态类型（Statically Typed）

• 定义：静态类型语言在编译时确定变量的类型，变量的类型在声明时明确且在整个生命周期内保持不变。
• 特征：
  • 变量必须在声明时指定类型。
  • 类型检查在编译时进行。
  • 不允许在同一变量中存储不同类型的数据。
• 示例语言：Java、C、C++、Go、Rust。

示例：C语言

#include <stdio.h>

int main() {
    int a = 10;           // 整数类型
    float b = 5.5;       // 浮点类型
    char c = 'A';        // 字符类型

    printf("a = %d\n", a);
    printf("b = %.2f\n", b);
    printf("c = %c\n", c);

    return 0;
}

对比

声明变量

a = "Hello World!"
print(a)

变量命名约定

Python变量命名规则

• 变量名只能由字母、数字和下划线组成
• 变量名只能以字母或下划线开头，不能以数字开头
• 变量名不区分大小写，但为了提高可读性，推荐使用小写字母命名，并用下划线分隔多个单词
• 变量名不能使用Python的关键字，如下：
  • ['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield']
• 变量名应该具有描述性，以便能够清晰地表达变量的含义

常见的命名方式

1. 大驼峰命名法（Camel case） 驼峰命名法是将多个单词连接在一起，每个单词首字母大写，这种命名方式常用于类、函数和对象的命名。

FirstName = '牛'
LastName = '老师'

print("你的名字是:",FirstName + LastName)

1. 下划线命名法（Snake case） 下划线命名法是将多个单词连接在一起，使用下划线（_）分隔每个单词，所有字母小写。这种命名方式常用于变量和模块名的命名。

first_str = 'Hello'
second_str = 'Python'

print(first_str + " " + second_str)

1. 全大写命名法（Pascal case / UPPERCASE） 全大写命名法是将多个单词连接在一起，每个单词所有字母大写，可以加上适当的分隔符如下划线。这种命名方式常用于常量或全局变量的命名。

FIRST_STR = 'Hello'
SECOND_STR = 'Python'

print( FIRST_STR+ " " + SECOND_STR)

变量的赋值

将某个数据赋值给某个变量存储

a = "变量1"
b = "变量2"

a = "变量1"
b = a

常量

常量是指在程序运行过程中其值不应被改变的变量。虽然 Python 本身并没有内置的常量类型，但有一些约定和方法可以用于定义常量。

定义常量：

常量通常是通过使用大写字母命名的变量来表示。这是一种约定，表明该变量不应被修改。例如：

PI = 3.14159
MAX_CONNECTIONS = 100

Python 没有内置的常量机制，但通过命名约定和模块结构，可以有效地使用常量来提高代码的可读性和可维护性。在设计大型程序时，合理使用常量是一个良好的编程习惯。

用户交互

INPUT(输入)

基本用法：

name = input('请输出你的姓名:')
print(name)

解释器在执行该代码的时候，如果遇到input就会出现阻塞，程序暂停，等待用户输入。当用户回车以后，程序才会继续向下执行

注意：通过input函数输入进来的内容一律会被当成字符串处理

a = input('请输入一个数字:')
print(type(a))
print(a > 0)

# Output:
请输入一个数字:10
<class 'str'>
Traceback (most recent call last):
  File "D:\Code\Code\Python\PythonProject\测试\deom1.py", line 3, in <module>
    print(a > 0)
TypeError: '>' not supported between instances of 'str' and 'int'

如果想要规定input输入的类型，需要做类型转换，如下所示：

a = int(input('请输入一个数字:'))
print(type(a))
print(a > 0)

# Output:
请输入一个数字:10
<class 'int'>
True

其他用法：

既然我们了解了input函数的特性，那么我们可以借助input函数来实现我们常见到的"按任意键结束......."

示例：

import time
a = 12345
b = 54321
print("开始计算a的b次方")
a1 = a**b
print("开始计算b的a次方")
b1 = b**a
print("开始比较大小")
time.sleep(5)
print(a1 > b1)
input("比较结束，请按任意键回车结束.....")

OUTPUT(输出)

基本用法：

a = "Hello world"
print(a)

格式化输出

name = input("姓名：")
age = input("年龄：")
job = input("工作：")
info = '''
----------- info of %s -----------
姓名：%s
年龄：%s
工作：%s
''' % (name,name,age,job)
print(info)

运行结果：

姓名：牛老师
年龄：18
工作：teacher

----------- info of 牛老师 -----------
姓名：牛老师
年龄：18
工作：teacher

字符串格式化标志(占位符)

以下是 Python 中字符串格式化的常见格式化标志及其说明：

• s：获取传入对象的 __str__ 方法的返回值，并将其格式化到指定位置。

• r：获取传入对象的 __repr__ 方法的返回值，并将其格式化到指定位置。

• c：

  • 整数：将数字转换成其 Unicode 对应的值（范围：0 <= i <= 1114111）。
  • 字符：将字符添加到指定位置。

• o：将整数转换成八进制表示，并将其格式化到指定位置。

• x：将整数转换成十六进制表示，并将其格式化到指定位置。

• d：将整数、浮点数转换成十进制表示，并将其格式化到指定位置。

• e：将整数、浮点数转换成科学计数法（小写 e），并将其格式化到指定位置。

• E：将整数、浮点数转换成科学计数法（大写 E），并将其格式化到指定位置。

• f：将整数、浮点数转换成浮点数表示，并将其格式化到指定位置（默认保留小数点后 6 位）。

• F：同上。

• g：自动调整，将整数、浮点数转换成浮点型或科学计数法表示（超过 6 位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是 e）。

• G：自动调整，将整数、浮点数转换成浮点型或科学计数法表示（超过 6 位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是 E）。

• %：当字符串中存在格式化标志时，需要用 %% 表示一个百分号。

示例：

# s：获取对象的 __str__ 方法返回值
name = "Alice"
print("Hello, %s!" % name)  # 输出: Hello, Alice!

# r：获取对象的 __repr__ 方法返回值
print("Name: %r" % name)  # 输出: Name: 'Alice'

# c：整数转换为其 Unicode 字符（0-1114111）
print("Unicode character: %c" % 65)  # 输出: Unicode character: A

# o：将整数转换为八进制表示
num = 10
print("Octal: %o" % num)  # 输出: Octal: 12

# x：将整数转换为十六进制表示
num = 255
print("Hexadecimal: %x" % num)  # 输出: Hexadecimal: ff

# d：将整数或浮点数转换为十进制表示
num = 42
print("Decimal: %d" % num)  # 输出: Decimal: 42

# e：将整数或浮点数转换为科学计数法（小写 e）
num = 123456789
print("Scientific: %e" % num)  # 输出: Scientific: 1.234568e+08

# E：将整数或浮点数转换为科学计数法（大写 E）
print("Scientific: %E" % num)  # 输出: Scientific: 1.234568E+08

# f：将整数或浮点数转换为浮点数表示，默认保留小数点后 6 位
num = 3.14159
print("Float: %f" % num)  # 输出: Float: 3.141590

# F：同上
print("Float: %F" % num)  # 输出: Float: 3.141590

# g：自动调整为浮点型或科学计数法，超出 6 位数使用科学计数法
num = 1234567.89
print("Auto: %g" % num)  # 输出: Auto: 1234567.89

# G：同上，但科学计数法用大写 E
print("Auto: %G" % num)  # 输出: Auto: 1234567.89

# %：表示一个百分号
percentage = 0.75
print("Percentage: %.2f%%" % (percentage * 100))  # 输出: Percentage: 75.00%

基本数据类型

整数(int)

• 描述：表示没有小数部分的数字，可以是正数、负数或零。
• 特性：
  • Python 3 中的 int 类型是无限大小的。这意味着你可以创建非常大的整数，而不必担心溢出（overflow）的问题。
  • Python 会根据整数的大小自动调整内存使用，因此可以存储任意大小的整数，只要计算机的内存允许。
  • 支持基本的算术运算，如加、减、乘、除等。

示例：

a = 10
b = -5
c = 0
print(a + b)
# Output: 5

可以使用type()内置函数来查看某个变量或值的数据类型

a = 2**64
print(type(a))    # type()是查看数据类型的方法
b = 2**60
print(type(b))

# Output:
<class 'int'>
<class 'int'>

字符串(str)

• 描述：字符串是字符的序列，可以通过单引号或双引号定义。
• 特性：
  • 字符串是不可变的（immutable），不能更改其内容。
  • 支持切片、连接、重复等操作。
  • 可以使用转义字符处理特殊字符。

在 Python 中, 加了引号的字符都被认为是字符串！

示例：

Greeting = "Welcome to 英格科技"
Name = "牛老师"
print(Greeting + " " + Name)    # 字符串可以通过+号进行拼接

# Output:
Welcome to 英格科技 牛老师

字符串的索引与切片

字符串的索引：

索引：每个字符在字符串中都有一个唯一的索引，索引从 0 开始。

负索引：可以使用负数索引从字符串的末尾开始访问字符，-1 表示最后一个字符，-2 表示倒数第二个字符，以此类推。

示例：

s = "Hello, World!"

# 正索引
print(s[0])  # 输出: H
print(s[7])  # 输出: W

# 负索引
print(s[-1])  # 输出: !
print(s[-5])  # 输出: W

字符串的切片：

切片：可以通过指定起始索引和结束索引来提取字符串的子串。切片的语法为 s[start:end]，包含起始索引的字符，但不包含结束索引的字符。

步长：可以指定步长来控制切片的间隔，语法为 s[start:end:step]。如果不指定步长，默认为 1。

示例：

s = "Hello, World!"

# 基本切片
print(s[0:5])  # 输出: Hello
print(s[7:12])  # 输出: World

# 省略起始或结束索引
print(s[:5])  # 输出: Hello (从开始到索引 4)
print(s[7:])  # 输出: World! (从索引 7 到结束)

# 使用负索引切片
print(s[-6:-1])  # 输出: World

# 步长切片
print(s[::2])  # 输出: Hlo ol! (每隔一个字符)
print(s[::-1])  # 输出: !dlroW ,olleH (反转字符串)

字符串常用方法

# 字符串操作示例

words = "beautiful is better than ugly."

# 字符串的基本操作
print(words.capitalize())   # 首字母大写
print(words.swapcase())     # 大小写翻转
print(words.title())        # 每个单词的首字母大写

# 内容居中，总长度，空白处填充
a = "test"
ret = a.center(20, "*")
print(ret)

# 统计字符串中的元素出现的个数
ret = words.count("e", 0, 30)
print(ret)

# startswith 和 endswith 判断
print(a.startswith("a"))             # 判断是否以 'a' 开头
print(a.endswith("j"))               # 判断是否以 'j' 结尾
print(a.startswith('sdj', 2, 5))     # 判断子串是否在指定范围内
print(a.endswith('ado', 7, 10))      # 判断子串是否在指定范围内

# 寻找字符串中的元素是否存在
print(a.find('sdj', 1, 10))          # 返回索引，找不到返回 -1
print(a.index('sdj', 1, 10))         # 返回索引，找不到抛出异常

# split 以指定字符分割，形成列表
ret = words.split(' ')
print(ret)
ret = words.rsplit(' ', 2)           # 指定分割次数
print(ret)

# format 的三种用法
print('{} {} {}'.format('aaron', 18, 'teacher'))
print('{1} {0} {1}'.format('aaron', 18, 'teacher'))
print('{name} {age} {job}'.format(job='teacher', name='aaron', age=18))

# strip 操作
a = '****asdasdasd********'
print(a.strip('*'))   # 去除两端指定字符
print(a.lstrip('*'))  # 去除左侧指定字符
print(a.rstrip('*'))  # 去除右侧指定字符

# replace 操作
print(words.replace('e', 'a', 2))  # 替换 'e' 为 'a'，替换两次

# 字符串类型检查
print(words.isalnum())  # 判断字符串是否只由字母或数字组成
print(words.isalpha())   # 判断字符串是否只由字母组成
print(words.isdigit())   # 判断字符串是否只由数字组成

布尔类型(bool)

• 描述：布尔类型只有两个值：True 和 False。
• 特性：
  • 通常用于条件判断和逻辑运算。
  • 布尔值在逻辑表达式中可以进行运算。

布尔类型很简单，就两个值 ，一个 True(真)，一个 False(假), 主要用记逻辑判断

示例：

a = 3
b = 5
print(a < b, a > b , a != b)

# Output:
True False True

基本运算符

算数运算符

用于执行基本的数学运算

关系运算符

用于比较两个值的关系

逻辑运算符

用于进行布尔逻辑运算

赋值运算符

用于给变量赋值

位运算符

用于对整数的二进制位进行操作

身份运算符

用于比较两个对象的内存地址

成员运算符

用于检查值是否在序列中

运算符优先级

以下表格列出了从最高到最低优先级的所有运算符：

注意事项

1. 括号优先：使用括号可以改变运算顺序，任何在括号内的运算会优先计算。
2. 运算符结合性：
   • 大多数运算符是从左到右结合的，例如加法和减法。
   • 幂运算 ** 是从右到左结合，即 2 ** 3 ** 2 等于 2 ** (3 ** 2)。
3. 比较运算符：比较运算符的优先级在逻辑运算符之前。
4. 赋值运算符：赋值运算符的优先级最低。

示例：

# 示例 1
result = 2 + 3 * 4  # 结果为 14，因为乘法优先于加法

# 示例 2
result = (2 + 3) * 4  # 结果为 20，因为括号改变了优先顺序

# 示例 3
result = 2 ** 3 ** 2  # 结果为 512，因为幂运算是右结合的

了解运算符优先级有助于在编写和阅读代码时清晰地理解表达式的计算顺序。