Python入门到入土

敬往事一杯酒哈

已于 2023-07-01 09:47:43 修改

阅读量229

点赞数

分类专栏： Python 文章标签： python pycharm 开发语言

于 2023-05-27 20:49:00 首次发布

本文链接：https://blog.csdn.net/A125679880/article/details/130904700

版权

Python 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

2、关系运算符也能比较字符串(按字典序，大小写相关)

四、逻辑运算符

1、逻辑运算符用于表达式的逻辑操作，有 and or not 三种，操作的结果是True或False

2、注意：

3、或逻辑表达式

4、非逻辑表达式

5、逻辑运算符的优先级（not > and > or）

6、逻辑表达式是短路计算的，即对逻辑表达式的计算，在整个表达式的值已经能够断定的时候即会停止

5、各种运算符的优先级

五、条件分支语句

1、为什么要使用条件分支语句：

编辑 2、if 语句中的语句组，每条语句左边必须缩进，且缩进情况必须一样(对齐）

3、什么相当于True或False

4、if 语句嵌套

5、在一条if语句的某个分支(语句组）里，还可以再写if语句。

2、异常处理（可使用try-except语句实现异常处理）

例题3. 输入正整数n(n>=2),求不大于n的全部质数

一、Python基础知识

1、程序的符号：

程序中的所有字符都必须是英文字符，不能是中文的字符，注意， : . ', ( " 之类的，都必须是英文字符！不能是中文的！不能在输入中文状态下输入！中文的标点符号看起来一般比英文的更宽。

2、注释

（1）、注释的作用：并非需要执行的指令，只是为了编程者方便理解程序之用。符号#

a = b   # 让a和b的值相同

（2）、注释的快捷键：Pycharm中，选中若干行，Ctrl + '/' 可将这些行都变成注释/都由注释变为非注释。

3、变量：

（1）、变量的定义：变量有名字，可以用来存储数据。其值可变。

a = 12
b = a		# 让b的值变得和a一样
print(a+b)
a = "hello"
print(a)

# 输出：
# 24
# hello

（2）、变量的命名办法：

变量由大小写字母、数字和下划线构成,中间不能有空格，长度不限，不能以数字开头。

例如：

name _doorNum x1

y

z

a2

A

number_of_students MYTYPE

（3）、变量名最好能够体现变量的含义。

（4）、多单词的变量名，最好第一个单词小写，后面单词首字母大写。

eg:

        dateOfBirth

        numOfDogs

         bookPrice

（5）、注意事项：

1、变量名是大小写相关的

a和 A, name 和 Name 是不同的变量。

2、有些名字Python预留了，不可用作变量的名字

如：and as assert break class continue def

del elif else except exec for finally from

global if import in is lambda not or pass

print raise return try while with yield

4、赋值语句

（1）、形式：变量 = 表达式

a = "he"
print(a) # >>he
b = 3+2
a = b         # a的值变得和b一样
print(b) # >>5
print(a)      # >>5
b = b + a     # b的值改为原来b的值加a
print(b) # >>10

a,b = "he",12

print(a,b)     # >>he 12

a,b = b,a     # 交换 a,b的值

print(a,b)      # >>12 he

c,a,b = a,b,a

print(a,b,c)    # >>he 12 12

a = b = c = 10

print(a,b,c)    #>>10 10 10

5、字符串初步

（1）、可以且必须用单引号、双引号或三单引号、三双引号括起来

x = "I said:'hello'"

print(x) # >>I said:'hello'

print('I said:"hello"') #>>I said:"hello"

print('''I said:'he said "hello"'.''') #>>I said:'he said "hello"'.

print("this \

is \

good") #>>this is good 字符串太长时，可以分行写

print( hello,word) #错！没有用引号括起来

（2）注意：

1、字符串里面不会包含变量：

s = 1.75

print(s) #>>1.75

print("I am s m tall") #>>I am s m tall

字符串中的 s 就是个字符，和前面的变量 s 没有关系!!!

2、字符串必须用引号括起来，用引号括起来的就是字符串！

a = 4

b = 5

print("a+b") #>> a+b 不会打出9!!!!!

（3）、三双引号字符串中可以包含换行符、制表符以及其他特殊字符。

para_str = """多行字符串可以使用制表符

多行字符串可以使用制表符

多行字符串可以使用制表符

多行字符串可以使用制表符

"""

print (para_str)

（4）、字符串的下标

有n个字符的字符串，其中的每个字符都是长度为1的字符串:

从左到右依次编号为 0,1,2... n-1

从右到左依次编号为 -1,-2...-n

编号就是下标

a = "ABCD"

print (a[-1]) #>>D

print (a[0]) #>>A

print (a[2]) #>>C

（5）、不可以修改字符串中的字符

a = "ABCD"

a[2] = 'k' #错，字符串中的字符不能修改

（6）、用"+"连接字符串

a = "ABCD"

b = "1234"

a = a + b

print(a) #>>ABCD1234

a = a + a[1]

print(a) #>>ABCD1234B

（7）、用 in , not in 判断子串

a = "Hello"

b = "Python"

print("el" in a) #>>True

print("th" not in b) #>>False

print("lot" in a) #>>False

*（8）、字符的切片：

若s是一个字符串，

则：

s[x:y]是s的从下标x到下标y的左边那个字符构成的子串(切片)

print("12345"[1:3]) #>> 23

a = "abcdef"

print(a[2:-1]) #>> cde

print(a[0:6]) #>> abcdef

6、字符串和数的转换

（1）、字符串和数的转换

int(x) : 把字符串转换成整数

(x不会变成整数， int(x)这个表达式的值是整数)

float(x) : 把字符串x转换成小数

str(x) : 把x转换成字符串

eval(x) : 把字符串x看作一个python表达式，求其值

初学者程序出现runtime error，多半是由于做了不合法的转换，如 int(x) 而 x 为"a12" 或 "12.34", float(x) 而x为 "abc"

（2）、例子

a = 15

b = "12"

c = a + b #错误的语句,字符串和整数无法相加

print(a + int(b)) #>>27 b没有变成整数 int(b)这个表达式的值是个整数

print(str(a) + b) #>>1512

c = 1 + float("3.5")

print(c) #>>4.5

print(3+eval("4.5")) #>>7.5

print(eval("3+2")) #>>5

print(eval("3+a")) #>>18

（3）int(x) ： x是小数，则去尾取整

int(3.2) #3

int(3.9) #3

7、 python数据类型：

8、输出语句print

print(x,y,z....) # 也可以只输出一项

连续输出多项，以空格分隔，然后换行

print(x,y,z...., end="")

连续输出多项，以空格分隔，不换行

print(1,2,3,end="")

print("ok")

#>>1 2 3ok

（1）、输出格式控制

Ø 字符串中的格式控制符 :

%s 表示此处要输出一个字符串

%d 表示此处要输出一个整数

%f 表示此处要输出一个小数

%.nf 表示此处要输出一个小数，保留小数点后面n位，四舍六入，五则可能入也可能舍。注意，有 '.'

......

格式控制符只能出现在字符串中！

例子：

h = 1.746

print("My name is %s,I am %.2fm tall." % ("tom",h))

print("My age is %d." % 18)

print("%d%s" % (18,"hello"))

print("%.2f,%.2f" % (5.225, 5.325)) #>> 5.22,5.33

输出：

My name is tom,I am 1.75m tall.

My age is 18.

18hello

5.22,5.33

9、输入语句input

格式：

x = input(y)

x 是变量

y 是字符串，或任何值为字符串的表达式

输出y，并等待输入。敲回车后输入的字符串被赋值给 x

例子：

s = input("请输入你的名字:")

print(s + ",你好！")

input() 每次输入一行，如果有多行输入，就用多次input()

        初学者常犯错误:

        如果输入已经结束（后面没有输入数据了），再进行input()，就会产生runtime error

        不要多行输入只用一次input，也不要一行输入用多次input

二、算术运算

1、Python 支持以下算术运算

a = (3+2)*(6-3)/2

print(a) #>>7.5

print(10/8) #>>1.25

print(10%8) #>>2

print(15/4) #>>3.75

print(15//4) #>>3

print(3.4/2.2) #>>1.5454545454545452

print(3.4//2.2) #>>1.0

print(2**3) #>>8

print(-9//4) #>>-3 往小里取整

2、/ 计算的结果都是小数，哪怕能整除

z = 10/2

print(z) #>>5.0

3、 -x 相当于 0-x

a = 10

print(-a) #>>-10

print(-a*3) #>>-30 等价于 (–a)*3

print(3+-5) #>>-2

4、有小数的算术表达式，结果就是小数

z = 10.0 - 10

print(z) #>>0.0

z = 7.5 – 2.5

print(z) #>>5.0

print(2+0*4.5) #>>2.0

print(2+10/5) #>>4.0

5、算术运算符优先级

第一级： **

第二级: -(求相反数)

第三级: * / // %

第四级: + -(减法)

可以用( ) 指定计算顺序: (3+4)*(1+2)

记不得优先级就用 ( )

6、算术运算的同时赋值

+= a += b 等价于 a = a + b

-= a -= b 等价于 a = a - b

*= ........

/=

%=

//=

**=

例子：

a = 6

a/=3

print(a) #>>2.0

a**=3

print(a) #>>8.0

7、常见问题或注意事项

数学上的运算符号或代数式写法，不是拿到程序里就能直接用的！

比如 |x| 在程序里并不能求x的绝对值，而是没定义，会出错！

2(x+3)(4+x) 这样的表达式也不能在程序里写！

应该写：

2*(x+3)*(4+x)

乘法就一定要用 '*' !

/ 的结果一定是小数。一个算术表达式，只要有一个操作数是小数，其结果就一定是小数。

如果x是小数print(x)就会打出小数形式，哪怕x = 4/2 。如果题目要求是整数，就要注意了，不要把整数当小数打出来。

print(4/2)打出 2.0

/ 是 ÷ ，不是分数线

a/b*c 是 a÷ b×c，不是a/(b*c)

三、关系运算

1、六种关系运算符用于比较大小

相等 ==

不等 !=

大于 >

小于 <

大于等于 >=

小于等于 <=

比较的结果是 bool 类型，成立则为 True, 反之为 False

bool 类型数据只有两种取值， True 或 False

例子：

print(3 < 5) #>>True
print(4 != 7) #>>True
a = 4
print(2 < a < 6 < 8) #>>True
print(2 < a == 4 < 6) #>>True
print(2 < a > 5) #>>False
b = a < 6
print(b) #>>True
print( b == 1) #>>True
print( b == 2) #>>False
b = a > 6
print( b == 0) #>>True

a = True
print(a == 1) #>>True

2、关系运算符也能比较字符串(按字典序，大小写相关)

a = "k"

print(a == "k") #>>True
a = "abc"
print(a == "abc") #>>True
print(a == "Abc") #>>False
print( "abc" < "acd") #>>True
print( "abc" < "abcd") #>>True

print("abc" > "Abc") #>>True

四、逻辑运算符

1、逻辑运算符用于表达式的逻辑操作，有 and or not 三种，操作的结果是True或False

与 :   exp1 and exp2

当且仅当exp1和exp2的值都为True（或相当于True）时，结果为True（或相当于True)

n = 4
n > 4 and n < 5          # false
n >= 2 and n < 5 and n%2 == 0    # true
print(5 and False)   #>>False
print(4 and True)    #>>True

2、注意：

l 0 ， "" ( 空字符串） , [] ( 空表 ), None 都相当于 False （但除 0 以外都不等于 False)

l 非 0 的数，非空的字符串和非空列表，都相当于 True （但除 1 以外，都不等于 True)

l True 和 1 完全等价， False 和 0 完全等价

True == 1 #True

False == 0 #True

"" == False #False

2 == True #False

[] == False #False

[2,3] == True #False

3、或逻辑表达式

l 或 :    exp1 or exp2

当且仅当exp1和exp2的值都为False（或相当于False）时，结果为False （或相当于False）

n = 4
n > 4 or n < 5    #True
n <= 2 or n > 5   #False

4、非逻辑表达式

非 : not exp

exp值为True(或相当于True)时, 结果为False(或相当于False)

exp值为False(或相当于False)时, 结果为True(或相当于True)

not 4 < 5 #False

not 5 #False

not 0 #True

not "abc" #False

not "" #True

not 4 < 5 and 4 > 6 #False

not [] #True

not [1] #False

5、逻辑运算符的优先级（not > and > or）

print(3 < 4 or 4 > 5 and 1 > 2 ) #>>True
print((3 < 4 or 4 > 5) and 1 > 2 ) #>>False

not 4 < 5 and 4 > 6 即 (not 4 < 5) and (4 > 6)

6、逻辑表达式是短路计算的，即对逻辑表达式的计算，在整个表达式的值已经能够断定的时候即会停止

exp1 and exp2 ：如果已经算出表达式 exp1 为假，那么整个表达式的值肯定为假，于是表达式 exp2 就不需要再计算

exp1 or exp2 ：如果已经算出 exp1 为真，那么整个表达式必定为真，于是 exp2 也不必计算

5、各种运算符的优先级

从高到低：

算术运算符 + - * / // % **

关系运算符 < > == != <= >=

逻辑运算符 and or not

记不得就勤用 ( )

print( 3 + 2 < 5 ) #>>False
print( 3 + (2 < 5)) #>>4 ,因 2 < 5相当于1

五、条件分支语句

1、为什么要使用条件分支语句：

有时，并非所有的程序语句都要被顺序执行到，会希望满足某种条件就执行这部分语句，满足另一条件就执行另一部分语句。这就需要“条件分支语句”。

2、if 语句中的语句组，每条语句左边必须缩进，且缩进情况必须一样(对齐）

if int(input()) == 5:
    print("a",end="")
    print("b")

输入：5 输出: ab

输入：4 无输出

对比下面：

if int(input()) == 5:
    print("a",end="")
print("b")

输入：4 输出: b

下面是错误的：

if int(input()) == 5:
    print("a",end="")
print("b")

出错！没有对齐的缩进!

3、什么相当于True或False

if "ok":
    print("ok") #>>ok
if "":
    print("null string") #无输出
a = [4,2]
if a:
    print(a) #>>[4,2]
if 20:
    print(20) #>>20
if 0:
    print(0) #无输出

4、if 语句嵌套

在一条 if 语句的某个分支 ( 语句组）里，还可以再写 if 语句。

a = int(input())
if a > 0:
    if a % 2:
        print("good")
    else:
        print("bad")

输入: 4 输出：bad

输入: 3 输出：good

输入: -1 无输出

5、在一条if语句的某个分支(语句组）里，还可以再写if语句。

a = int(input())
if a > 0:
    if a % 2:
        print("good")
else:
    print("bad")

输入: 4 无输出

输入: 3 输出：good

输入: -1 bad

六、循环语句

1、for 循环语句

for <variable> in <sequence>:

<statements 1>

else:

<statements 2>

依次对 sequence中的每个值,执行 <statements 1>

然后再执行 <statements 2>。通常不需要 else 部分

sequence 可以是range(..)，也可以是字符串、列表、元组、字典、集合

举个栗子：

for i in range(5):  #[0,5)
     print(i)
0
1
2
3
4
for i in range(5,9) : #[5,9)
    print(i)
5
6
7
8
for i in range(0, 10, 3) :  #步长3
    print(i)
0
3
6
9

（1）、for循环遍历列表 – 写法1

a = ['Google', 'Baidu', 'IBM', 'Taobao', 'QQ']
for i in range(len(a)):	# len,求列表长度（元素个数）
    print(i, a[i]) 

0 Google
1 Baidu
2 IBM
3 Taobao
4 QQ

len也可以用来求字符串长度，元组、集合、字典元素个数
print(len("abc"))     #>>3

（2）、for循环遍历列表 – 写法2

a = ['Google', 'Baidu', 'IBM', 'Taobao', 'QQ']
for i in a:	
    print(i) 

Google
Baidu
IBM
Taobao
QQ

(3)、for循环遍历字符串

for letter in 'Taobao':
	print (letter)
输出：
T
a
o
b
a
o

（4）、break语句：

sites = ["Baidu", "Google","IBM","Taobao"]  #list
for site in sites:  #对sites中的每个值 site
    if site == "IBM":
        print("OK")
        break		#跳出循环	
    print("site: " + site)
else:
    print("No break")
print("Done!")


输出：
site: Baidu
site: Google
OK
Done!

注意：else子句在循环结束时会执行，但是如果break了，则不会执行

（5）、continue语句：

for letter in 'Taobao':
   if letter == 'o':        # 字母为 o 时跳过输出
      continue		 #  直接跳到下次循环
   print ('当前字母 :', letter)


当前字母 : T
当前字母 : a
当前字母 : b
当前字母 : a

（6）、连续输出26个字母

for i in range(26): 
    print(chr(ord("a") + i),end="")

输出：
abcdefghijklmnopqrstuvwxyz 

函数说明：
ord(x)  求字符 x 的编码  (字符就是长度为1的字符串）

chr(x)  求编码为x的字符

（7）、连续输出0 - 9

for i in range(10):
    print(chr(ord("0") + i),end="")
输出:
0123456789      #'0'-'9'的ASCII编码是连续的

（8）、for循环例题

例题1. 输入n个整数求和


n = int(input())
total = 0
for i in range(n):    #做n次
	total += int(input())  #每次读入一行
print(total)

例题2. 从小到大输出n的因子

n = int(input())        # 输入一个正整数n，从小到大输出它的所有因子
for x in range(1,n+1):
    if n % x == 0:       
        print(x," ",end="")

输入：15 ↙
输出：1 3 5 15

例题3.输入一个正整数n，从大到小输出它的所有因子

n = int(input())
for x in range(n,0,-1):  #步长-1
    if n % x == 0:
        print(x," ",end="")
输入：15 ↙
输出：15 5 3 1

例4 输入一个大于等于2的正整数，判断是否为素数(for 语句实现)。

num=int(input())
for i in range(2,num): 
# i从2到num-1
	if num % i == 0:
	    print("不是素数")
          break
else:
  	    print("是素数")

2、多重循环

（1）、定义：

嵌套循环是由一个外循环和一个或多个内层循环构成。每次重复外层循环时，内层循环都要重新进入并要重新循环一遍。

for i in range(n):
    .....
    for j in range(m):
        ..... #内重循环的执行次数一共是n×m次

举个栗子：

for i in range(3):           #外层循环    
     for j in range(10):      #内层循环   
         print(str(i)+str(j),end=' ')
     print()                  #换行
运行结果：  
00 01 02 03 04 05 06 07 08 09 
10 11 12 13 14 15 16 17 18 19 
20 21 22 23 24 25 26 27 28 29
print语句执行次数 ：30次

（2）、多重循环例题：

例1：多次求n个数的和

m = int(input()) 
for i in range(m): #m组数据，所以要处理m次
    n = int(input()) 
    total = 0
    for i in range(n): #n个数，每个一行，所以要input n次
        total += int(input())
    print(total)

3、while 循环：

（1）、while循环语句

while 逻辑表达式 exp :

语句组1

else:

语句组2

........

1) 判断 exp 是否为真，若为真，转 2) ，若为假，转 3)

2) 执行语句组 1 ，回到 1)

3) 执行语句组 2

4) 继续往下执行 ........

count = 0
while count < 5:
    print (count, " 小于 5")
    count = count + 1
else:
    print (count, " 大于或等于 5")

输出：
0  小于 5
1  小于 5
2  小于 5
3  小于 5
4  小于 5
5  大于或等于 5

（2）、连续输出26个字母


i = 0
while i < 26:
    print(chr(ord("a") + i),end="")
    i+=1

abcdefghijklmnopqrstuvwxyz      # 字母的ASCII编码是连续的

（3）、while例子

例题: 输入一个正整数 n ， 从小到大 输出它的所有因子

n = int(input())
x = 1
while x <= n:
    if n % x == 0:
        print(x," ",end="")
    x += 1

例题: 提示用户输入密码，密码不正确则提示不正确，

然后要求输入，密码正确则提示成功，然后结束。密码是pku

while (input("请输入密码:")!= "pku"):
	print("密码不正确！")
print("密码输入成功!")

（4）、break语句

while True:

........

if exp:

break

.....

●

不停执行，直到 exp为真时跳出循环

举个栗子：输入三个整数，求它们的最小公倍数

s = input().split()
x,y,z = int(s[0]),int(s[1]),int(s[2])
n = 1
while True:
    if n % x == 0 and n % y == 0 and n % z == 0:
        print(n)
        break
    n = n + 1

七、异常处理

1、定义：

在程序运行过程中如果发生异常，Python 会输出错误消息和关于错误发生处的信息，然后终止程序。

2、异常处理（可使用try-except语句实现异常处理）

例如：

short_list = [1, 72, 3]

position = 6

try:

    short_list[position]

except:

    print('索引应该在 0 和', len(short_list)-1,"之间,但却是",position)

输出：

索引应该在 0 和 2 之间，但却是 6

•

3、例子：

例除数为0的异常处理

x=int(input())
y=int(input())
try:
    result = x / y
except ZeroDivisionError:
    print("division by zero!")
else:
    print("result is", result)
finally:
    print("executing finally clause")


程序输入：
6
4
程序输出：
result is 1.5
executing finally clause


程序输入：
5
0
程序输出：
division by zero!
executing finally clause

4、常见的异常有：

1) 不合适的转换，例如 int (" abc ") int ("23.34") float(" abc ")

2) 输入已经结束（已经没有输入数据了）后，还执行 input()

3) 除法除数为 0

4) 整数和字符串相加 5) 列表下标越界（比如 3 个元素的列表用到了下标 4)

八、循环综合例题

例题1. 求斐波那契数列第k项

k = int(input())
if  k == 1 or k == 2:
    print(1)
else:
    a1 = a2 = 1
    for i in range(k-2):
        a1,a2 = a2,a1+a2
    print(a2)

例题2. 求阶乘的和

n = int(input())
s,f = 0,1
for i in range(1,n+1):
    f *= i
    s += f
print(s)

例题3. 输入正整数n(n>=2),求不大于n的全部质数

n = int(input())
print(2)
for i in range(3,n+1,2): #步长2,只判断奇数
    ok = True
    for k in range(3,i,2):
        if i % k == 0:
            ok = False
            break
        if k*k > i: #大于根号i的数就不用试了
            break
    if ok:
        print(i)

九、函数和递归

1、思考：为什么需要函数？

“函数”：将实现了某一功能，并需要在程序中多处使用的代码包装起来形成一个功能模块（即写成一个“函数”），那么当程序中需要使用该项功能时，只需写一条语句，调用实现该功能的 “函数”即可。

2、函数定义：

内置函数：len(“hello”)、sum(a+b)

3、自定义函数：

• def f(x):

• value=x**2+1

• return value

• n= int (input())

• y=f(n)

• print(y)

自定义函数的格式：

def 函数名(参数1, 参数2 ……):

语句组(即“函数体”)

也可以没有参数：

def 函数名():

语句组(即“函数体”)

4、函数调用和函数的返回值：

函数名（参数1,参数2，……）

对函数的调用，也是一个表达式。函数调用表达式的值，由函数内部的return语句决定。return语句语法如下：

return 返回值

return语句的功能是结束函数的执行，并将“返回值”作为结果返回。“返回值”是常量、变量或复杂的表达式均可。如果函数不需要返回值，return语句就直接写：

return

例：函数的返回值是函数(函数和字典的组合)

def test(par):

return(par)

def test1():

return(1000)

def test2(par):

return(2000)

def f(x):

return { 'a': test, 'b': test1,}.get(x, test2)

print(f('a')(100))

print(f(“4”)(100))

5、匿名函数---lambda表达式

lambda的一般形式是关键字lambda后面跟一个或多个参数，紧跟一个冒号，后面是一个表达式。作为表达式，lambda返回一个值。

g = lambda x,y,z : x+y+z

#把lambda定义的匿名函数赋给函数g

print（g(1,4,5)） #输出10

6、函数使用例子：

函数使用实例1：判断素数

def IsPrime(n):
    if n <= 1 or n % 2 == 0 and n != 2:
        return False
    elif n == 2:
        return True
    else:
        for i in range(3,n,2):
            if n % i == 0:
                return False
            if i * i > n:
                break
    return True
for i in range(100):
    if( IsPrime(i)):
        print(i,end = " ")	
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97

函数使用实例2：斐波那数列求f(n)的前n项值。

def fibs(n):	 #函数定义
        result=[0,1]	
        for i in range(n-2):
             result.append(result[-2]+result[-1])
        return result  #返回列表
    print(fibs(5))      函数调用

函数使用实例3：整数M和N区间内素数的个数并对它们求和(2<=M<N)

def isprime(i):
     for k in range(2,i):
          if i%k==0:
              return False
     return True
 
m,n=input().split()
m,n=int(m),int(n)
p=[i for i in range(m,n+1) if isprime(i)]
print(len(p),sum(p))

7、形参和实参

思考：当函数的形参值改变后会影响相应的实参吗？

当实参是不可变对象时，形参值改变不会影响实参！

当实参是可变对象时，形参值改变可能会影响实参！

未完待续。。。