【Python】python基本语法和使用

介绍：

Python 是开发效率高、生态强大但性能偏弱的一种编程语言，适合快速开发和上层应用；而C++ 是性能极强、控制能力强但开发成本高的系统级语言，适合底层和高性能场景；两者不是对立的，而是互补的，很多大型项目都是用 C++ 做核心，Python 做上层封装，兼顾效率和性能。

1，标准输入输出

1，标准输入

python 使用 input 函数，从控制台读取用户的输入。类似 C++ 中的scanf。

input 从控制台或终端等待你输入一行内容，按回车结束，它读到的内容一律是字符串类型。它返回值就是用户输入的内容，是字符串类型，想当数字用必须强转。

# 基本用法

s = input()

# 带提示文字

name = input("请输入名字：") # 输入12，name的数据是控制台上的输入
print("你好", name) # 输出：你好 12

age = int(input("请输入年龄：")) # 类型强转int
score = float(input("请输入分数：")) # 类型强转float

a = input('请输入第一个整数: ')
a = int(a)

2，标准输出

print(1 + 2 - 3) # 输出0
print(1 + 2 * 3) # 输出7
print(1 + 2 / 3) # 输出1.6666666666666665

num = 10

print(f'num = {num}') # 输出num = 10

print('num = {num}') # 输出num = {num}

name = input("请输入名字：") # 输入12
print("你好", name) # 输出你好 12

name = 'python'

print("你好" + name) # 输出你好python

print("你好" + num) # 输出错误，+ 两边类型不一样

print 是一个 Python 内置的标准输出函数，函数内，可以使用 + - * / ( ) 等运算符进行算术运算。先算乘除，后算加减。运算符和数字之间，可以没有空格，也可以有多个空格。

使用 f 作为前缀的字符串，称为 f-string，里面可以使用 { } 来内嵌一个其他的变量或表达式。

print("你好", name)这里的逗号表示这是两个独立的参数，即"你好"和"name"是两个独立参数。Python 规定，多个参数输出时，自动加一个空格分隔，因此输出时两参数中间有一个空格。

print("你好" + name)里面 "+" 两边的类型必须一致，不一致会报错。

注意：C/C++中，2 / 3 结果为 0 (小数部分被截断)，而 // 运算符才会进行取整运算。但是在 Python 中得到的结果则是一个小数。其次，Python中，单行注释符号是'#'，多行注释符号是 """ 或者 '''。

2，变量和类型

Python和C++等语言不同，Python变量的类型不需要显式指定，而是在赋值的时候确定的，类型是自动推断的。

a = 10

a = 15
b = 20
a = b
print(a)
print(b)

print(a ** 2) # 输出400

Python里，变量 ** 2 就是求这个变量的 2 次方。** 是 Python 的幂运算符，例如，x ** 3 就是立方，x ** 0.5 就是开平方。

1，整形int

a = 10

print(type(a)) # 输出<class 'int'>

注意：Python 和 C++ 等语言不同，Python 的 int 类型变量，表示的数据范围是没有上限的。只要内存足够大，理论上就可以表示无限大小的数据。

2，浮点数float

a = 0.5

print(type(a)) # 输出<class 'float'>

注意：Python 和 C++ 等语言不同，Python 的小数只有 float 一种类型，没有 double 类型，但是实际上 Python 的 float 就相当于 C++ 的 double，表示双精度浮点数。

3，字符串str

a = 'hello'

print(len(a)) # 输出5

b = 'world'

print(a + b) # 输出helloworld

print(type(a)) # 输出<class 'str'>

使用 ' ' 或者 " " 引起来的，称为字符串。在 Python 中，单引号构成的字符串和双引号构成的字符串没有区别，例如，'hello' 和 "hello" 是完全等价的。这里可以使用 len 函数来获取字符串的长度，还可以使用 + 针对两个字符串进行拼接。字符串作为开发中最常用到的数据类型，支持的操作方式也是非常丰富的，用到时根据其他语言经验进行理解即可，这里不再一一说明。

4，布尔型bool

布尔类型是一个特殊的类型，取值只有两种，True (真) 和 False (假)。

a = True
print(type(a)) # 输出<class 'bool'>
b = False
print(type(b)) # 输出<class 'bool'>

a = 10
b = 20
c = 30
print(a < b and b < c)****# 输出True

print(a < b and b > c)****# 输出False

print(a > b or b > c)****# 输出False

print(a < b or b > c)****# 输出True

print(not a < b)****# 输出False

print(not a > b)****# 输出True

and or not 这一系列的运算符称为逻辑运算符。and 类似 C/C++ 中的 "&&"，or 类似 C/C++ 中的 "||"，not 类似 C/C++ 中的 "!"。

5，列表list和元组

1，列表

list是 Python 中的可变序列类型。里面元素按放入顺序排列，有下标（索引），且可以增、删、查、改元素，允许出现相同值和任意类型混放。

a = $1,2,3$

print(type(a)) # 输出<class 'list'>

b = $1, 2, 3, "hello", \[4, 5$ , True]

# 增添元素

b.append(40) # 末尾添加
b.insert(0, 5) # 指定位置插入(索引下标0，第一个元素)

print(b) # 输出 $5, 1, 2, 3, 'hello', \[4, 5$ , True, 40]

# 删除元素

b.pop() # 删除最后一个
b.pop(0) # 删除指定下标
b.remove(20) # 删除第一个值为20的元素
del b $1$ # 直接删除
b.clear() # 清空

# 查找元素

print(b $0$ ) # 输出1

print(b $-1$ ) # 输出True（倒数第一个）

print(b $-2$ ) # 输出 $4, 5$ （倒数第二个，后面类似）

# 修改元素

b $1$ = 999

len(b) # 获取长度
alist = $1, 2, 3, 4$
print(alist $1:3$ ) # 输出 $2, 3$

alist = $1, 2, 3, 4$
print(alist $1:$ ) # 省略后边界, 表示获取到列表末尾
print(alist $:-1$ ) # 省略前边界, 表示从列表开头获取
print(alist $:$ ) # 省略两个边界, 表示获取到整个列表

# 指定步长，也就是每访问一个元素后，下标自增几步

alist = $1, 2, 3, 4, 5, 6, 7, 8, 9, 10$
print(alist $::1$ )
print(alist $::2$ )
print(alist $::3$ )
print(alist $::5$ )

# 指定的步长还可以是负数，此时是从后往前进行取元素

alist = $1, 2, 3, 4, 5, 6, 7, 8, 9, 10$
print(alist $::-1$ )
print(alist $::-2$ )
print(alist $::-3$ )
print(alist $::-5$ )

# 如果填写的数字越界了，不会有负面效果，只会尽可能的把满足条件的元素过去到

alist = $1, 2, 3, 4$

print(alist $3:200$ ) # 输出 $4$

2，元组

元组的功能和列表相比基本是一致的，不同的是元组使用 "()" 来表示。其次，元组不能修改里面的元素，列表则可以修改里面的元素，操作与列表基本都是一样的。

6，dict字典类型

dict 是键值对映射，用来存 "名字 - 内容" 这种对应关系的数据，是 Python 里最常用的映射类型。该类型等同于 C++ 的 std::map/std::unordered_map。

# 基本语法
d = {} # 空字典

b = dict()

person = {
"name": "张三",
"age": 20,
"height": 175.5
} # 有数据的字典

# 取值

print(person $"name"$ ) # 张三
print(person.get("age")) # 20

# 修改或添加

person $"age"$ = 21 # 修改
person $"gender"$ = "男" # 新增

# 查找。使用 in 可以判定 key 是否在字典中存在，返回布尔值

print('id' in person) # 输出False

print('name' in person) # 输出True

# 删除

del person $"height"$
person.pop("age")
person.clear() # 清空

# 遍历
for k in person:
print(k)
for key in student:
print(key, student $key$ )

7，动态类型

Python中，一个变量是什么类型，是可以在程序运行过程中发生变化的。这个特性称为动态类型。变量不用声明类型，赋值什么类型，它就是什么类型，运行时可以随便改。

a = 10 # 现在是 int

a = "hello" # 现在变成 str

a = $1,2,3$ # 又变成 list

特点：

不用提前写类型。
同一个变量，运行时可以变类型。
类型是跟值绑定，不是跟变量名绑定。

Python 3.5+ 支持类型注解，只是给人看、给编辑器提示，不影响运行。

age: int = 18
name: str = "张三"
height: float = 1.75
is_student: bool = True

nums: list $int$ = $1,2,3$
user: dict $str, str$ = {"name": "Tom", "sex": "male"}

3，条件语句

Python 的条件语句就是 if/elif/else，和 C++ 逻辑一样，但写法更简单。

if 条件1:
代码块
elif 条件2:
代码块
else:
代码块

条件后面必须加冒号 ":"，代码块用缩进表示（跟C++不一样，不用大括号），缩进一般是4个空格。

score = 85

if score >= 90:
print("优秀")
elif score >= 60:
print("及格")
else:
print("不及格")

条件语句中有一个空语句pass，不会对程序的执行有任何影响，只是占个位置，保持 Python 语法格式符合要求。

a = int(input("请输入一个整数:"))
if a != 1:
pass
else:
print("hello")

# 上面逻辑与下面等价
a = int(input("请输入一个整数:"))
if a == 1:
print("hello")

4，循环语句

1，while 循环

while 条件:
循环体代码
i = 1
while i <= 5:
print(i)

if i == 5:

break
i = i + 1

2，for 循环

Python 的 for 主要用来遍历东西，比如列表、字符串。

for 循环变量 in 可迭代对象:
循环体
nums = $10, 20, 30$
for n in nums:
print(n)

s = "hello"
for c in s:
print(c)

# 打印1-10

for i in range(1, 11):

if i == 3:

continue

print(i)

5，函数

Python 函数用 def 定义，和 C++ 的函数思路一样，但写法更简单。

def 函数名(参数):
函数体
return 返回值

函数用 def 关键字，括号里是参数（可以没有），后面必须加冒号 ":"，函数内代码用缩进，return 用来返回结果（可以没有）。

# 定义求和函数
def calcSum(beg, end):
sum = 0
for i in range(beg, end + 1):
sum += i
print(sum)

在不同的作用域中，允许存在同名的变量。Python 的作用域跟 C/C++ 不同，需要使用 "{}" 说明作用域，Python 依靠缩进表明作用域，这块根据 C/C++ 作用域理解运用即可。如果是想在函数内部修改全局变量的值，需要使用 global 关键字声明。

x = 20 # 全局作用域
def test():
x = 10 # 函数内部作用域
print(f'函数内部 x = {x}') # x = 10

test()
print(f'函数外部 x = {x}') # x = 20
x = 20
def test():
global x
x = 10
print(f'函数内部 x = {x}') # 函数内部 x = 10
test()
print(f'函数外部 x = {x}') # 函数外部 x = 10

一个函数是可以一次返回多个返回值的。使用 "," 来分割多个返回值。如果只想关注其中的部分返回值，可以使用 "_" 来忽略不想要的返回值。

def getPoint():
x = 10
y = 20
return x, y
a, b = getPoint() # a = 10, b = 20

def getPoint():
x = 10
y = 20
return x, y
_, b = getPoint() # b = 20

Python 中的函数，可以给形参指定默认值。这块跟 C++ 用法类似，不再具体说明。

def add(x, y, debug=False):
if debug:
print(f'调试信息: x={x}, y={y}')
return x + y

print(add(10, 20))
print(add(10, 20, True))

字段参数这块，Python 还可以通过关键字参数来调整这里的传参顺序，显式指定当前实参传递给哪个形参。

def test(x, y):

print(f'x = {x}')

print(f'y = {y}')

test(x=10, y=20)

test(y=100, x=200)

最后要说的是，编程语言中，很多语法都是相同的，掌握一门语言后，在学习其他语言后，很多知识都是互通类似的。

6，文件

open 打开文件。close 关闭已经打开的文件。write 方法写入文件。read 读取文件，readline 可以读取一行，readlines读取整个文件内容。这块接口跟 C 中的接口类似。

# 读取文件

f = open('d:/test.txt', 'r', encoding='utf8') # 使用utf8编码方式
result = f.read(2) # 读取两个字符
print(result)
f.close()

f = open('d:/test.txt', 'r')
lines = f.readline() # 读取一行。文件每行都自带换行符
print(lines)
f.close()

f = open('d:/test.txt', 'r')
for line in f:
print(f'line = {line}') # 一次读取一行
f.close()

f = open('d:/test.txt', 'r')
lines = f.readlines() # 直接把文件整个内容读取出来，包括每行末尾的换行符
print(lines)
f.close()

# 写入文件

f = open('d:/test.txt', 'w')
f.write('hello')
f.close()