C++基础讲解第三期（超详细）每天更新哈，大家一起加油
Posted Alex、WY
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了C++基础讲解第三期（超详细）每天更新哈，大家一起加油相关的知识，希望对你有一定的参考价值。
C++基础讲解第三期 代码中也有对应知识注释，别忘看，一起学习！
一、面向编程练习（根据前两篇笔记，先来个题目练练手吧）
要求：设计一个圆形类和一个点类，计算点在圆外还是圆内还是圆上，求点和圆的关系
- 点
属性：横坐标和纵坐标
方法：点和点之间的距离 - 圆
属性：圆心，半径
方法：设置圆心和半径，判断点和圆的关系
//circle.cpp
#include"circle.h"
#include<cmath>
void Dit::set(int x, int y)
m_x = x;
m_y = y;
int Dit::getx()
return m_x;
int Dit::gety()
return m_y;
double Dit::Distance(Dit d)
double s;
s = sqrt((d.m_x - m_x)*(d.m_x - m_x) + (d.m_y-m_y)*(d.m_y-m_y));
cout << "d.m_x = " << d.m_x << "d.m_y = " << d.m_y<<"m_x= "<< m_x<<"m_y= "<< m_y <<endl;
cout << "两点之间的距离是：" << s << endl;
return s;
void Circle::set(int x, int y, int r)
m_d.set(x ,y);
m_r = r;
void Circle::Relationship(Dit d)
double distance = d.Distance(m_d);
if(distance == m_r)
cout<< "点在圆上" << endl;
else if(distance > m_r)
cout << "点在圆外" << endl;
else
cout << "点在园内" << endl;
//circle.h
#ifndef _H_CIRCLE_
#define _H_CIRCLE_
#include<iostream>
using namespace std;
class Dit
private:
int m_x;
int m_y;
public:
double Distance(Dit d);
void set(int x, int y);
int getx();
int gety();
;
class Circle
private:
Dit m_d;
int m_r;
public:
void set(int x, int y, int r);
void Relationship(Dit d);
;
#endif
#include"circle.h"
int main()
int d_x = 1;
int d_y = 1;
Dit d;
Circle c;
d.set(1, 1);
c.set(3, 4, 5);
c.Relationship(d);
return 0;
二、对象的构造和析构
1、构造函数
在C++中，有一种特殊的成员函数，它的名字和类名相同，没有返回值，不需要用户显示调用（也不能调用），而且在创建对象的时候自动执行。这种特殊的成员函数称为构造函数
几点说明：
1.构造函数的函数名和类名必须相同
2.构造函数不能有返回值，函数体内不能有return语句
3.构造函数在定义对象时会自动调用，不需要手动调用
#include<iostream>
using namespace std;
class Array
private:
int *data; //数组的起始地址
int size; //数组的大小
public:
Array(); //无参构造函数，函数名和类名相同，没有返回值，完成对象的初始化操作
void SetVal(int index,int val);
int GetVal(int index);
~Array(); //析构函数，函数名是：类名+~，没有返回值
;
Array::Array()
cout<<"array的无参构造函数"<<endl;
size = 5;
data = (int *)malloc(sizeof(int)*size);
void Array::SetVal(int index,int val)
data[index] = val;
int Array::GetVal(int index)
return data[index];
Array::~Array() //析构函数，函数名是：类名+~，没有返回值
cout<<"Array的析构函数"<<endl;
if(NULL != data)
free(data);
data = NULL;
int main()
Array a1; //创建对象时自动调用构造函数
for(int i = 0; i < 5; i++)
a1.SetVal(i,i+1);
for(int i = 0;i<5;i++)
cout << a1.GetVal(i) << "" <<endl;
return 0;
输出为：
array的无参构造函数
1 2 3 4 5
Array的析构函数
2.构造函数的重载和调用
和普通函数一样，构造函数时允许重载的，一个类可以有多个重载的构造函数，在创建对象时根据传递的实参去决定调用哪个构造函数。
#include<iostream>
using namespace std;
class Array
private:
int *data; //数组的起始地址
int size; //数组的大小
public:
Array(); //无参构造函数，函数名和类名相同，没有返回值，完成对象的初始化操作
Array(int s); //有参构造函数
Array(int s, int z); //有两个参数的构造函数
void SetVal(int index,int val);
int GetVal(int index);
~Array(); //析构函数，函数名是：类名+~，没有返回值
;
Array::Array()
cout<<"array的无参构造函数"<<endl;
size = 5;
data = (int *)malloc(sizeof(int)*size);
Array::Array(int s)
size = s;
data = (int *)malloc(sizeof(int)*size);
cout <<"Array的有参构造函数, size = " << size <<endl;
Array::Array(int s, int z)
size = s;
data = (int *)malloc(sizeof(int)*size);
cout <<"Array的两个参数的构造函数, size= "<< size << endl;
void Array::SetVal(int index,int val)
data[index] = val;
int Array::GetVal(int index)
return data[index];
Array::~Array() //析构函数，函数名是：类名+~，没有返回值
cout<<"Array的析构函数"<<endl;
if(NULL != data)
free(data);
data = NULL;
int main()
/*
Array a1; //创建对象时自动调用构造函数
for(int i = 0; i < 5; i++)
a1.SetVal(i,i+1);
for(int i = 0;i<5;i++)
cout << a1.GetVal(i) << "" <<endl;
*/
Array a2(6);//初始化方式为括号法
Array a3(7,8);
Array a4 = 100;//初始化方法为等号法，有局限，只能有一个参数
return 0;
运行结果：
Array的有参构造函数, size = 6
Array的两个参数的构造函数, size= 7
Array的有参构造函数, size = 100
Array的析构函数
Array的析构函数
Array的析构函数
3、拷贝构造函数
1.概念
格式：className(const className &obj)
拷贝构造函数也称为赋值拷贝构造函数
作用：用一个已有的对象去初始化另一个对象
Array::Array(const Array &a)
cout<<"Array的拷贝构造函数"<<endl;
2.拷贝构造函数调用的时机
1）用一个对象初始化另一个对象
Array a5 = a4;
Array a6(a4);
Array a7 = Array(a4);
2）当函数的形参是一个对象时，比如：
void print(Array a)
a.GetVal(1);
Array a1;
print(a1);
输出结果为：
Array的有参构造函数, size = 100
Array的拷贝构造函数
Array的析构函数
Array的析构函数
注意：这里，我在有参的构造函数中，给data指针分配了内存，在析构中free了内存，所以当我们在拷贝构造函数中没有给指针分配内存时，那么这个指针的内存会被释放两次，那么就会发生crash，这一点后面会讲到。这里没有crash是因为我将析构函数中的free函数注释了
3）函数返回值是一个对象
Array& Func()
Array a1;
return a1;
Array a2 = Func();
首先会调用无参构造函数，因为Func中创建了a1对象，将a1 return时，会产生匿名对象(没有名字的对象)，因为这时候a1被释放了(因为a1是局部的)，那么这时候用这个a1匿名对象初始化a2，就会调用匿名对象的拷贝构造函数，编译器实际上不会给a2分配空间，而是将匿名对象给了a2，直接用a2给这个匿名对象命名，所以不会产生两次拷贝构造。
3、深拷贝
#include<iostream>
using namespace std;
class Array
private:
int *data;
int size;
public:
Array(int s)
cout <<"array的有参构造函数"<<endl;
size = s;
data = (int *)malloc(sizeof(int)*size);
~Array()
cout <<"array的析构函数"<<endl;
if(data != NULL)
free(data);
data = NULL;
Array(Array &a)//深拷贝构造函数
cout <<"array的深拷贝构造函数"<< endl;
size = a.size;
data = (int*)malloc(sizeof(int)*size);//和浅拷贝的区别在于，重新给指针分配了空间，用于保存数组中的值。不会和被拷贝的数组同用一片空间
for(int i = 0; i < size; i++)
data[i] = a.data[i];
;
int main()
Array a1(10);
Array a2(a1);
return 0;
输出：
array的有参构造函数
array的深拷贝构造函数
array的析构函数
array的析构函数
4、默认构造函数
#include<iostream>
using namespace std;
class Test
public:
Test()
cout <<"Test 的无参构造函数"<<endl;
Test(int a)
cout <<"Test 的一个参数构造函数"<<endl;
Test(const Test &a)
cout <<"Test 的拷贝构造函数"<<endl;
;
int main()
Test t1;//编译器会默认提供无参构造函数
Test t2(t1);//编译器会提供默认的拷贝构造函数（浅拷贝）
Test t3;//一旦提供了无参构造函数，编译器就不再提供无参构造函数
Test t4;//一旦提供了有参的构造函数，编译器不会再提供默认的无参构造函数
Test t5;//一旦提供了拷贝构造函数，编译器也不会再提供默认的无参构造函数
return 0;
5、析构函数
1). 格式： ~Array()析构函数
2). 概念：
当一个对象销毁时，系统会自动调用一个函数来进行清理工作，如释放内存，关闭打开的文件，这个函数就是析构函数。
析构函数没有参数，不能被重载，一个类中只能有一个析构函数，如果用户没有提供析构函数，编译器会自动生成一个默认的析构函数。
6、匿名对象
#include<iostream>
using namespace std;
class Test
public:
Test()
cout <<"Test 的无参构造函数"<<endl;
Test(int a)
cout <<"Test 的一个参数构造函数"<<endl;
Test(const Test &a)
cout <<"Test 的拷贝构造函数"<<endl;
~Test()
cout<<"test的析构函数"<<endl;
;
int main()
Test(); //匿名对象，本行代码执行完毕，立即被释放，也就是立即调用析构函数
cout<<"*************"<<endl;
return 0;
7、对象的动态创建和释放(malloc、free、new、delete）
1） c++中 malloc使用
#include<iostream>
using namespace std;
class Test
public:
Test()
cout <<"Test 的无参构造函数"<<endl;
Test(int a)
cout <<"Test 的一个参数构造函数"<<endl;
Test(const Test &a)
cout <<"Test 的拷贝构造函数"<<endl;
~Test()
cout<<"test的析构函数"<<endl;
;
int main()
//Test t1; 栈空间创建对象
//c++中不用malloc，是因为其不会自动调用构造函数和析构函数
Test *pt = (Test *)malloc(sizeof(Test));//在堆空间申请一个对象大小的内存
if(NULL == pt)
cout << "malloc is failed" <<endl;
free(pt);
pt = NULL;
Test *pt2 = new Test; //在堆中申请内存，并且自动调用构造函数
delete pt2; //自动调用析构函数
pt2 = NULL;
int *p2 = new int;//给整形分配空间
delete p3;
p3 = NULL;
char *p3 = new char;//给一个字符申请空间
delete p3;
p3 = NULL;
char *p4 = new char[10]; //给10个字符申请空间
detele []p4;
p4 = NULL;
Test *t2 = new Test(1);//给一个Test对象申请空间，并且初始化
delete t2;
t2 = NULL;
Test *t3 = new Test[5]1,2,3,4,5;//申请十个Test类对象，并初始化
return 0;
2）malloc和new的区别？
1.malloc是函数，new是关键字
2.malloc的返回值类型是void*， new是申请空间的类型
3.malloc不能初始化空间，new可以初始化
4.malloc不能自动调用构造函数，new可以
8、构造函数的参数初始化列表
#include<iostream>
using namespace std;
class Date
private:
int m_year;
int m_month;
int m_day;
public:
/* Date()
cout<<"data的无参构造函数"<<endl;
m_year = 1998;
m_month = 6;
m_day = 28;
*/
Date(int y, int m, int d)
cout << "data的有参构造函数"<< endl;
m_year = y;
m_month = m;
m_day = d;
~Date()
cout <<"data的析构函数"<< endl;
;
calss Test
private:
Test超详细的 Python 基础语句总结(多实例视频讲解持续更新)
目录
- 一、运算符
- 1.1 + ——两个对象相加
- 1.2 - ——得到负数或是一个数减去另一个数
- 1.3 * ——两个数相乘或是返回一个被重复若干次的字符串、列表、元组
- 1.4 / ——两个数相除
- 1.5 // ——返回商的整数部分（向下取整）
- 1.6 % ——返回除法的余数
- 1.7 ** ——返回一个数的幂
- 1.8 = —— 简单的赋值
- 1.9 += —— 加法赋值
- 1.10 -= —— 减法赋值
- 1.11 *= —— 乘法赋值
- 1.12 /= —— 除法赋值运算符
- 1.13 %= —— 取模赋值运算符
- 1.14 **= —— 幂赋值运算符
- 1.15 //= —— 取整除赋值运算符
- 1.16 == —— 等于运算符
- 1.17 != —— 不等于运算符
- 1.18 > —— 大于运算符
- 1.19 < —— 小于运算符
- 1.20 >= —— 大于等于运算符
- 1.21 <= —— 小于等于运算符
- 1.22 and —— 与运算符
- 1.23 or—— 或运算符
- 1.24 not—— 非运算符
- 1.25 & —— 按位与运算符
- 1.26 | —— 按位或运算符
- 1.27 ^ —— 按位异或运算符
- 1.28 ~ —— 按位取反运算符
- 1.29 << —— 左移动运算符
- 1.30 >> —— 右移动运算符
- 1.31 in —— 在指定的序列中查找
- 1.32 not in —— 在指定的序列中查找
- 1.33 is —— 判断两个标识是否引自同一个对象
- 1.34 is not —— 判断两个标识是否引自同一个对象
- 二、流程控制
-
- 三、函数
-
- 四、程序调试与异常处理
-
一、运算符
1.1 + ——两个对象相加
+ 运算符用于实现 2 个对象的相加。视频讲解链接如下：
https://www.bilibili.com/video/BV1Ao4y1m7nh
【示例1】数字相加。在 Python 中，经常会遇到使用 + 进行数值相加的情况，常用应用如下：
a = 13
b = 2
c = 4.0
d = 5.0
print(a + b) # 整数相加 15
print(c + d) # 浮点数相加 9.0
print(a + c) # 整数和浮点数相加 17.0
print(a + .5) # 整数和省略零的浮点数相加 13.5
【示例2】字符串相加。在 Python 中，如果 + 号的两侧是字符串类型数据，则表示将 2 个字符串进行拼接。常用应用如下：
s1 = 'Amo'
s2 = 'Xiang'
print(s1 + s2) # 字符串拼接
print(s1 + ' ' + s2) # 2个字符串间添加空格
print(s1 + '\\n' + s2) # 2个字符串间添加换行符
程序执行结果如下图所示：
【示例3】元组、列表相加。当元组、列表使用 + 相加时，返回合并后的元组、列表。常用应用如下：
t1 = (1, 2, 3)
t2 = (4, 5, 6)
t3 = ('a', 'b', 'c')
t4 = ('d', 'e', 'f')
t5 = (('o', 'p', 'q'), ('x', 'y', 'z'))
print(t1 + t2) # (1, 2, 3, 4, 5, 6)
# (1, 2, 3, 4, 5, 6, 'a', 'b', 'c', 'd', 'e', 'f')
print(t1 + t2 + t3 + t4)
# (1, 2, 3, 4, 5, 6, 'a', 'b', 'c', 'd', 'e', 'f', ('o', 'p', 'q'), ('x', 'y', 'z'))
print(t1 + t2 + t3 + t4 + t5)
print("*" * 90)
l1 = [1, 2, 3]
l2 = [4, 5, 6]
l3 = [['a', 'b', 'c']]
l4 = [['d', 'e', 'f']]
l5 = [['o', 'p', 'q'], ('x', 'y', 'z')]
print(l1 + l2) # [1, 2, 3, 4, 5, 6]
# [['a', 'b', 'c'], ['d', 'e', 'f']]
print(l3 + l4)
# [1, 2, 3, 4, 5, 6, ['a', 'b', 'c'], ['d', 'e', 'f'], ['o', 'p', 'q'], ('x', 'y', 'z')]
print(l1 + l2 + l3 + l4 + l5)
说明：字典和集合不能使用“+”进行操作。
说明：不同数据类型，不能直接进行 + 运算。如下：
1.2 - ——得到负数或是一个数减去另一个数
- 运算符在 Python 中有两个作用，一个是作为负号使用，在数字前表示负数；另一个是作为减号，表示前一个数字减去后一个数字。
【示例1】作为负号使用。作为负号使用时，注意负负为正。常用应用如下：
num1 = 4
num2 = -5
num3 = -6.0
print(-num1) # -4
print(num2) # -5
print(-num3) # 6.0
【示例2】作为减号使用。作为减号使用时，常用应用如下：
num1 = 5
num2 = 1
num3 = 10
num4 = 8.0
print(num1 - num2) # 4
print(num1 - num3) # -5
print(num1 - num4) # -3.0
1.3 * ——两个数相乘或是返回一个被重复若干次的字符串、列表、元组
* 运算符在 Python 中有两个作用，一个是作为乘号使用，表示两个数相乘；另一个是和整数 n 组合，作为重复符号使用，表示字符串、列表、元组重复 n 次。
【示例1】作为乘号使用。作为乘号使用时，常用应用如下：
num1 = 3
num2 = 4
num3 = 5.5
num4 = -6
print(num1 * num2) # 12
print(num1 * num3) # 16.5
print(num1 * num4) # -18
【示例2】对字符串使用*号。使用“*”作为重复符号，打印一个等腰三角形。代码如下：
print(' ' * 2 + '*' + ' ' * 2)
print(' ' + '*' * 3 + ' ')
print('*' * 5)
【示例3】对元组使用*号。“*”号作为重复符号，同样可以作用在元组上。
l1 = (1, 2, 3)
l2 = (('a', 'b', 'c'), ('d', 'e', 'f'))
# (1, 2, 3, 1, 2, 3, 1, 2, 3)
print(l1 * 3)
# (('a', 'b', 'c'), ('d', 'e', 'f'), ('a', 'b', 'c'), ('d', 'e', 'f'))
print(l2 * 2)
【示例4】对列表使用*号。“*”号作为重复符号，同样可以作用在列表上。
l1 = [1, 2, 3]
l2 = [['a', 'b', 'c']]
board = [['-'] * 3 for i in range(3)] # 使用列表解析式
# [1, 2, 3, 1, 2, 3, 1, 2, 3]
print(l1 * 3)
# [['a', 'b', 'c'], ['a', 'b', 'c'], ['a', 'b', 'c']]
print(l2 * 3)
# [['-', '-', '-'], ['-', '-', '-'], ['-', '-', '-']]
print(board)
1.4 / ——两个数相除
/ 运算符用于实现 2 个对象的相除。
【示例1】实现人民币和美元的转换。已知1美元兑换人民币 6.78 元，编写程序实现人民币转换成美元的功能。代码如下：
exchange_rate = 6.78 # 汇率
RMB = input('请输入人民币金额：')
try:
US = float(RMB) / exchange_rate
print('转化后的美元是:{:.2f}'.format(US))
except ValueError:
print('请输入正确的数值类型。')
程序执行结果如下图所示：
1.5 // ——返回商的整数部分（向下取整）
// 运算符用于取整除，返回商的整数部分，注意向下取整。例如 8 // 3 = 2。
【示例1】将描述“秒”转化为“分 秒”的格式。在考试系统中需要记录用户的答题时间。通常答题时间是以秒为单位记录的。比如用时“100”秒，为了增加可读性，需要将“100秒”转化为“1分钟40秒“的形式。如下代码，可以实现该功能：
def second_format(seconds):
minutes = seconds // 60 # 计算分钟数
if minutes > 0:
seconds = seconds - minutes * 60 # 计算剩余秒数
return minutes, seconds
i = 2
while i > 0:
seconds = input('请输入秒数：')
result = second_format(int(seconds))
print(f'{seconds}秒可以转化为{result[0]}分{result[1]}秒')
i -= 1
程序执行结果如下图所示：
【示例2】统计程序运行所占用的内存。psutil 是个跨平台库模块，能够轻松实现获取系统运行的进程和系统利用率，包括CPU、内存、磁盘、网络等信息。使用“pip install psutil”命令安装psutil模块，然后统计程序运行所占用的内存，并将其转化MB单位大小。代码如下：
import os
import psutil
def show_memory_info(hint):
"""显示当前Python程序占用的内存大小"""
pid = os.getpid()
p = psutil.Process(pid)
info = p.memory_full_info()
memory = info.uss / 1024. / 1024 # 1MB = 1024KB = 1024B
print('{} memory used: {} MB'.format(hint, memory))
# 测试函数占用多少内存
show_memory_info('initial')
list_val = [i for i in range(10000000)]
show_memory_info('finished')
程序执行结果如下图所示：
1.6 % ——返回除法的余数
% 运算符用于取模，返回除法的余数，例如 8%2 结果为 0，8%3 结果为2。
【示例1】负数使用%求余数。计算下面的除法求余结果：
result1 = 8 % 3
result2 = -8 % 3
result3 = 8 % -3
result4 = 0 % -3 # 0
result5 = 0 % 6 # 0
print(f"8 % 3 的结果是：{result1}") # 2
print(f"-8 % 3 的结果是：{result2}") # 1
print(f"8 % -3 的结果是：{result3}") # -1
上面的结果可能与很多人的预期不符，这个结果是由 Python 机制决定的。在 Python 中取余数遵循下面的公式：
r=a-n*(a//n)
# r=a-n*(a//n)
# 8 % 3 ==> a=8,n=3 ==> 8-3*(8//3) ==> 8-3*2 ==> 2
# 注意：-8//3 计算时向下取整，结果为-3，而不是-2。
# -8 % 3 ==> a=-8,n=3 ==> -8-3*(-8//3) ==> -8-3*(-3) ==> -8+9 ==> 1
# 8 % -3 ==> a=8,n=-3 ==> 8-(-3)*(8//-3) ==> 8+3*(-3) ==> 8-9 ==> -1
1.7 ** ——返回一个数的幂
** 运算符用于返回一个数的幂，例如 2 ** 2 结果为4 ，2 ** 3 结果为8。
【示例1】用 3 种方式求 x 的 y 次幂。
import math
# 计算x的y次幂
x = 10
y = 3
# 方式1
print(x ** y) # 1000
# 方式2
print(pow(x, y)) # 1000
# 方式3
print(math.pow(x, y)) # 返回类型为浮点型: 1000.0
1.8 = —— 简单的赋值
= 是简单的赋值运算符，例如将 a=1，表示将数值 1 赋值给变量 a。
【示例1】不同类型数据的赋值。
# 常用数据类型赋值
num = 123 # 数值
str_val = "Amo" # 字符串
tuple_val = (1, 2, 3) # 元组
list_val = [1, 2, 3] # 列表
dict_val = {"name": "Amo", "age": 18} # 字典
set_val = {1, 2, 3} # 集合
def fun():
print("函数赋值")
f = fun # 函数赋值
f() # 调用函数：函数赋值
class Student:
def __init__(self):
print("类赋值")
s = Student # 类赋值
s() # 类的实例化：类赋值
1.9 += —— 加法赋值
+= 是加法赋值运算符，例如将 a +=1,等价于 a=a+1。
【示例1】计算字典中各值的累加和。
basket = {"fruit": 45.80, "meat": 20.45, "juice": 10} # 购物车数据
total = 0 # 初始化总价
# 方式1：
for item in basket.values():
total += item
print(f'方式1的计算结果为{total}')
# 方式2：
total = sum(basket.values())
print(f'方式2的计算结果为{total}')
【示例2】将数字0-9自动转化为汉字。
numbers = input("请输入0-9之间的数字:")
digits_mapping = {
"0": "零",
"1": "壹",
"2": "贰",
"3": "叁",
"4": "肆",
"5": "伍",
"6": "陆",
"7": "柒",
"8": "捌",
"9": "玖",
}
output = ""
for number in numbers: # 遍历输入的数字
output += digits_mapping.get(number, "!") + " " # 匹配字典的键，然后将结果连接在一起
print(output)
1.10 -= —— 减法赋值
-= 是减法赋值运算符，如加法运算符类似，例如将a -=1,等价于a=a-1。
【示例1】“逢7过”游戏。“逢7过”是一个锻炼头脑敏捷性的益智游戏。游戏规则是大家围成一圈，然后从1开始依序喊数字，如果数字是7或者7的倍数，就不能喊出这个数字，必须做一个动作。使用Python 计算出200以内的7的倍数。例如7、14、28等。代码如下：
value = 200 # 初始值
L = []
while value > 0:
if value % 7 == 0: # 如果被7整除
L.append(value) # 添加到列表
value -= 1
L.reverse() # 列表反转
print(L) # 输出列表
1.11 *= —— 乘法赋值
“*=”是乘法赋值运算符，如加法运算符类似，例如将a *=3,等价于a = a*3。
【示例1】多种类型使用乘法赋值。对不同类型数据使用乘法赋值运算，代码如下：
# 数字
num = 5
num *= 3
print(num) # 15
# 字符串
str_val = "Amo"
str_val *= 3
print(str_val) # AmoAmoAmo
# 元组
tuple_val = (1, 2, 3)
tuple_val *= 3
print(tuple_val) # (1, 2, 3, 1, 2, 3, 1, 2, 3)
# 列表
list_val = [1, 2, 3]
list_val *= 3
print(list_val) # [1, 2, 3, 1, 2, 3, 1, 2, 3]
【示例2】计算摆满国际象棋所需要的麦子数。国际象棋共有64个格子，如果第一个小格内放入一粒麦子，在第二个小格内放入两粒，第三小格内放入给四粒，以此类推，每一小格内都比前一小格加一倍的麦子，直至放满64个格子，总共需要多少颗麦子。代码如下：
def getNumberOfWheat(grid):
"""
获取放grid格时的麦子数
:param grid: 格子数
:return: 返回放满格子数时的麦子数量
"""
g_sum = 0
numberOfWhearInGrid = 1 # 第一个格子放置1粒
g_sum += numberOfWhearInGrid # 第一个格子的总粒数
for i in range(2, grid + 1): # 从第2个格子开始，遍历每一个格子
numberOfWhearInGrid *= 2 # 下一个格子是前一个格子的2倍
g_sum += numberOfWhearInGrid # 计算所有格子中总粒数
return g_sum
print(f"放满4个格子需要{getNumberOfWheat(4)}颗麦子") # 由于第1个格子默认放置1，所以从第2个开始计算共63个格子
print(f'放满64个格子需要{getNumberOfWheat(64)}颗麦子') # 由于第1个格子默认放置1，所以从第2个开始计算共63个格子
1.12 /= —— 除法赋值运算符
/= 是除法赋值运算符，例如将 a /=3,等价于 a = a/3。
【示例1】用2种方式对列表中的元素批量相除。
list_value = [1, 2, 3, 4, 5]
# 方式1：
new_value = [i / 2 for i in list_value] # 使用列表解析式
print(new_value) # [0.5, 1.0, 1.5, 2.0, 2.5]
# 方式2：
new_value = []
for i in list_value:
i /= 2 # 除法赋值运算
new_value.append(i) # 追加到新列表
print(new_value) # [0.5, 1.0, 1.5, 2.0, 2.5]
1.13 %= —— 取模赋值运算符
%= 是取模运算符，例如将 a %= 3,等价于a = a%3。
【示例1】对列表中的元素批量取模。
list_value = [10, 11, 12, 13, 14, 15]
new_value = []
for i in list_value:
i %= 2 # 取模运算
val = '奇数' if i else '偶数' # 三元表达式
new_value.append(val) # 追加到新列表
print(new_value) # ['偶数', '奇数', '偶数', '奇数', '偶数', '奇数']
1.14 **= —— 幂赋值运算符
“**=”是幂赋值运算符，例如将a **= 3,等价于a = a**3。
【示例1】用3种方式对列表中的元素批量求平方。
list_value = [1, 2, 3, 4, 5]
# 方式1：
new_value = [i ** 2 for i in list_value] # 使用列表解析式
print(new_value) # [1, 4, 9, 16, 25]
# 方式2
new_value = []
for i in list_value:
i **= 2 # 幂赋值操作
new_value.append(i) # 追加到新列表
print(new_value) # [1, 4, 9, 16, 25]
# 方式3
new_value = list(map(lambda x: x ** 2, list_value))
print(new_value) # [1, 4, 9, 16, 25]
1.15 //= —— 取整除赋值运算符
“//=”是取整除赋值运算符，例如将a //= 3,等价于a = a//3。
【示例1】用3种方式对列表中的元素批量取整数赋值
list_value = [1, 2, 3, 4, 5]
# 方式1：
new_value = [i // 2 for i in list_value] # 使用列表解析式
print(new_value) # [0, 1, 1, 2, 2]
# 方式2
new_value = []
for i in list_value:
i //= 2
new_value.append(i) # 追加到新列表
print(new_value) # [0, 1, 1, 2, 2]
# 方式3
new_value = list(mapC++入门C和C++混合编程超详细讲解
C语言从入门到入土（进阶篇）函数栈帧的创建和销毁讲解（不看必后悔系列）（超详细）