介绍：

        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()