python基础语法（笔记总结）

python 基础语法

源自菜鸟教程

python简介

• python是一种解释型语言： 这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。
• Python 是交互式语言： 这意味着，您可以在一个 Python 提示符 >>> 后直接执行代码。
• Python 是面向对象语言: 这意味着Python支持面向对象的风格或代码封装在对象的编程技术。
• Python 是初学者的语言：Python 对初级程序员而言，是一种伟大的语言，它支持广泛的应用程序开发，从简单的文字处理到 WWW 浏览器再到游戏。

python 程序

· 交互式编程

交互式编程不需要创建脚本文件，是通过 Python 解释器的交互模式进来编写代码。
Window 上在安装 Python 时已经安装了交互式编程客户端，提示窗口如下：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fqEPe52k-1603101461476)(attachment:1%20%282%29.PNG)]

· 脚本式编程

通过脚本参数调用解释器开始执行脚本，直到脚本执行完毕。当脚本执行完成后，解释器不再有效。

基础语法

· Python 标识符

在 Python 里，标识符由字母、数字、下划线组成。
在 Python 中，所有标识符可以包括英文、数字以及下划线(_)，但不能以数字开头。
Python 中的标识符是区分大小写的。
Python 可以同一行显示多条语句，方法是用分号 ; 分开，如：

print("hello");print('runoob');

hello
runoob

· Python 保留字符

下面的列表显示了在Python中的保留字。这些保留字不能用作常数或变数，或任何其他标识符名称。
所有 Python 的关键字只包含小写字母。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PR2zRW5x-1603101461482)(attachment:3.PNG)]

· 多行语句

Python语句中一般以新行作为语句的结束符。
但是我们可以使用斜杠（ \）将一行的语句分为多行显示，如下所示：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ifTUDWTX-1603101461483)(attachment:4.PNG)]
语句中包含 [], {} 或 () 括号就不需要使用多行连接符。如下实例：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SQL3anUN-1603101461485)(attachment:10.PNG)]

· Python 引号

Python 可以使用引号( ’ )、双引号( " )、三引号( ‘’’ 或 “”" ) 来表示字符串，引号的开始与结束必须是相同类型的。
其中三引号可以由多行组成，编写多行文本的快捷语法，常用于文档字符串，在文件的特定地点，被当做注释。

word = 'word'
sentence = "这是一个句子。"
paragraph = """这是一个段落。
包含了多个语句"""
print(word)
print(sentence)
print(paragraph)

word
这是一个句子。
这是一个段落。
包含了多个语句

ps：三引号与#注释的区别是，三引号中的多行文本可以进行代码的实现

· Python注释

python中单行注释采用 # 开头。

# 第一个注释
print ("Hello, Python!")  # 第二个注释

Hello, Python!

python 中多行注释使用三个单引号(’’’)或三个双引号(""")。

'''
这是多行注释，使用单引号。
这是多行注释，使用单引号。
这是多行注释，使用单引号。
'''

"""
这是多行注释，使用双引号。
这是多行注释，使用双引号。
这是多行注释，使用双引号。
"""

'\n这是多行注释，使用双引号。\n这是多行注释，使用双引号。\n这是多行注释，使用双引号。\n'

· print 输出

换行输出&不换行输出

x="a"
y="b"
# 换行输出
print(x)
print(y)
print('---------') 
# 不换行输出
print(x,y) 

a
b
---------
a b

· 多个语句构成代码组

缩进相同的一组语句构成一个代码块，我们称之代码组。
像if、while、def和class这样的复合语句，首行以关键字开始，以冒号( : )结束，该行之后的一行或多行代码构成代码组。
我们将首行及后面的代码组称为一个子句(clause)。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hqd1kJJI-1603101461487)(attachment:9.PNG)]

Python 变量类型

· 变量赋值

每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
等号 = 用来给变量赋值。
等号 = 运算符左边是一个变量名，等号 = 运算符右边是存储在变量中的值。例如：

counter = 100  # 赋值整型变量
miles = 1000.0  # 浮点型
name = "John"  # 字符串
print(counter)
print(miles)
print(name)

100
1000.0
John

· 多个变量赋值

Python允许你同时为多个变量赋值。例如：

a = b = c = 1

以上实例，创建一个整型对象，值为1，三个变量被分配到相同的内存空间上。
您也可以为多个对象指定多个变量。例如：

a, b, c = 1, 2, "john"

以上实例，两个整型对象 1 和 2 分别分配给变量 a 和 b，字符串对象 “john” 分配给变量 c。

· 标准数据类型

在内存中存储的数据可以有多种类型。
例如，一个人的年龄可以用数字来存储，他的名字可以用字符来存储。
Python 定义了一些标准类型，用于存储各种类型的数据。
Python有五个标准的数据类型：

• Numbers（数字）
• String（字符串）
• List（列表）
• Tuple（元组）
• Dictionary（字典）

· Python字符串

字符串或串(String)是由数字、字母、下划线组成的一串字符。
从字符串中获取一段子字符串的话，使用 [头下标:尾下标] 来截取相应的字符串，其中下标是从 0 开始算起，可以是正数或负数，下标可以为空表示取到头或尾。[头下标:尾下标] 获取的子字符串包含头下标的字符，但不包含尾下标的字符。

str = 'Hello World!'
 
print(str)          # 输出完整字符串
print(str[0])       # 输出字符串中的第一个字符
print(str[2:5])      # 输出字符串中第三个至第六个之间的字符串
print(str[2:])     # 输出从第三个字符开始的字符串
print(str * 2)       # 输出字符串两次
print(str + "TEST")  # 输出连接的字符串

Hello World!
H
llo
llo World!
Hello World!Hello World!
Hello World!TEST

Python 列表截取可以接收第三个参数，参数作用是截取的步长，以下实例在索引 1 到索引 4 的位置并设置为步长为 2（间隔一个位置）来截取字符串：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8lXZ63wn-1603101461489)(attachment:11.PNG)]

Python列表

List（列表） 是 Python 中使用最频繁的数据类型。
列表可以完成大多数集合类的数据结构实现。它支持字符，数字，字符串甚至可以包含列表（即嵌套）。
列表用 [ ] 标识，是 python 最通用的复合数据类型。
列表中值的切割也可以用到变量 [头下标:尾下标] ，就可以截取相应的列表，从左到右索引默认 0 开始，从右到左索引默认 -1 开始，下标可以为空表示取到头或尾。
加号 + 是列表连接运算符，星号 * 是重复操作。如下实例：

list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]
tinylist = [123, 'john']
 
print(list)              # 输出完整列表
print (list[0])            # 输出列表的第一个元素
print (list[1:3])          # 输出第二个至第三个元素 
print (list[2:])           # 输出从第三个开始至列表末尾的所有元素
print (tinylist * 2)       # 输出列表两次
print (list + tinylist)    # 打印组合的列表

['runoob', 786, 2.23, 'john', 70.2]
runoob
[786, 2.23]
[2.23, 'john', 70.2]
[123, 'john', 123, 'john']
['runoob', 786, 2.23, 'john', 70.2, 123, 'john']

Python 元组

元组是另一个数据类型，类似于 List（列表）。
元组用 () 标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。

tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )
tinytuple = (123, 'john')
 
print (tuple)               # 输出完整元组
print (tuple[0])            # 输出元组的第一个元素
print (tuple[1:3])          # 输出第二个至第四个（不包含）的元素 
print (tuple[2:])           # 输出从第三个开始至列表末尾的所有元素
print (tinytuple * 2)       # 输出元组两次
print (tuple + tinytuple)   # 打印组合的元组

('runoob', 786, 2.23, 'john', 70.2)
runoob
(786, 2.23)
(2.23, 'john', 70.2)
(123, 'john', 123, 'john')
('runoob', 786, 2.23, 'john', 70.2, 123, 'john')

以下是元组无效的，因为元组是不允许更新的。而列表是允许更新的：

tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )
list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]
tuple[2] = 1000    # 元组中是非法应用
list[2] = 1000     # 列表中是合法应用

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

 in 
      1 tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )
      2 list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]
----> 3 tuple[2] = 1000    # 元组中是非法应用
      4 list[2] = 1000     # 列表中是合法应用


TypeError: 'tuple' object does not support item assignment

Python 字典

字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。列表是有序的对象集合，字典是无序的对象集合。
两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典用"{ }"标识。字典由索引(key)和它对应的值value组成。

dict = {
     }
dict['one'] = "This is one"
dict[2] = "This is two"
 
tinydict = {
     'name': 'runoob','code':6734, 'dept': 'sales'}
 
 
print(dict['one'])        # 输出键为'one' 的值
print(dict[2])      # 输出键为 2 的值
print(tinydict)    # 输出完整的字典
print(tinydict.keys())  # 输出所有键
print(tinydict.values())# 输出所有值
print(dict.keys())  # 输出所有键
print(dict.values())# 输出所有值

Python数据类型转换

int() 函数用于将一个字符串或数字转换为整型。
float() 函数用于将整数和字符串转换成浮点数。
complex() 函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。
str() 函数将对象转化为适于人阅读的形式。(就是转化为字符串）
tuple() 函数将列表转换为元组。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WUL9t6jQ-1603101461490)(attachment:13.PNG)]
list() 方法用于将元组转换为列表。
注：元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是放在括号中，列表是放于方括号中。

int(3.6)

float(112)

complex(1, 2)

complex(1)  # or complex("1")

complex("1+2j")
# 注意：这个地方在"+"号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错

tuple((1,2,3,4))

Python 运算符

算术运算符

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xx740qjP-1603101461490)(attachment:14.PNG)]

位运算符

按位运算符是把数字看作二进制来进行计算的。
ps：这个不太会，等以后有需要的时候再学吧

身份运算符

身份运算符用于比较两个对象的存储单元(is)
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-p7YWYL2E-1603101461491)(attachment:15.PNG)]

Python 条件语句

其中"判断条件"成立时（非零），则执行后面的语句，而执行内容可以多行，以缩进来区分表示同一范围。
else 为可选语句，当需要在条件不成立时执行内容则可以执行相关语句。

a = 1
while a < 7 :
    if(a % 2 == 0):
        print(a,"is even")
    else:
        print(a,'is odd')
    a += 1

当判断条件为多个值时，可以使用以下形式：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3I9IFDHH-1603101461492)(attachment:16.PNG)]

num = 9
if num >= 0 and num <= 10:    # 判断值是否在0~10之间
    print( 'hello')
# 输出结果: hello
 
num = 10
if num < 0 or num > 10:    # 判断值是否在小于0或大于10
    print ('hello')
else:
    print ('undefine')
# 输出结果: undefine
 
num = 8
# 判断值是否在0~5或者10~15之间
if (num >= 0 and num <= 5) or (num >= 10 and num <= 15):    
    print( 'hello')
else:
    print ('undefine')
# 输出结果: undefine

Python 循环语句

while循环

while 语句用于循环执行程序，即在某条件下，循环执行某段程序，以处理需要重复处理的相同任务。
while 语句时还有另外两个重要的命令。continue 条件成立，不执行后面操作，重头开始循环；break 则是用于退出循环。
如果条件判断语句永远为 true，循环将会无限的执行下去，此时可以使用 Ctrl+C来中断循环。

#range(10) means 从1挨个取值到10
for i in range(10):
    if i%2 != 0:
        print(i)
        continue
    i += 2
    print(i)
#如i是奇数，则输出i；如i是偶数，则输出i+2

while循环也可以使用else

count = 0
while count < 5:
   print (count, " is  less than 5")
   count = count + 1
else:
   print (count, " is not less than 5")

for 循环语句

Python for循环可以遍历任何序列的项目，如一个列表或者一个字符串。

for letter in 'Python':     # 第一个实例
   print ('当前字母 :', letter)
 
fruits = ['banana', 'apple',  'mango']
for fruit in fruits:        # 第二个实例
   print ('当前水果 :', fruit)
#有点神奇，第一次知道for循环还可以循环字符串

通过序列索引迭代

另外一种执行循环的遍历方式是通过索引，如下实例：

fruits = ['banana', 'apple',  'mango']
for index in range(len(fruits)):
   print ('当前水果 :', fruits[index])
#len(fruits)=3,所以从0开始检索，到2结束（因为最后一个数字所代表的值是不检索的）

for 中的语句和普通的没有区别，else 中的语句会在循环正常执行完（即 for 不是通过 break 跳出而中断的）的情况下执行，while … else 也是一样。

for num in range(10,20):  # 迭代 10 到 20 之间的数字
   for i in range(2,num): # 根据因子迭代
      if num%i == 0:      # 确定第一个因子
         j=num/i          # 计算第二个因子
         print ('%d 等于 %d * %d' % (num,i,j))
         break            # 跳出当前循环
   else:                  # 循环的 else 部分
      print( num, '是一个质数')

pass 语句

pass 是占据一个位置，因为如果定义一个空函数程序会报错，当你没有想好函数的内容是可以用 pass 填充，使程序可以正常运行。

def function():
    # 在Python3.x的时候pass可以写或不写
    pass

Python Number(数字)

Python数学函数

cmp(x,y) 如果xy,返回1
fabs(x) 返回绝对值
pow(x,y) x**y运算后的值
sqrt(x) 平方根

Python随机数函数

choice（seq） 从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。
random() 随机生成下一个实数，它在[0,1)范围内。

uniform(x, y) 随机生成下一个实数，它在[x,y]范围内。

字符串运算符(r/R)

原始字符串:所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。

print('hello')
print(r'\n')
print('world')

print('hello')
print ('\n')
print('world')

Python 元组

元组中只包含一个元素时，需要在元素后面添加逗号 tup1 = (50,)
元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:

tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
 
# 以下修改元组元素操作是非法的。
# tup1[0] = 100
 
# 创建一个新的元组
tup3 = tup1 + tup2
print(tup3)

(12, 34.56, 'abc', 'xyz')

删除元组

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如下实例:

print(tup2)
del(tup1)
# print(tup1)

('abc', 'xyz')

%who

a	 b	 c	 counter	 function	 list	 miles	 name	 paragraph	 
sentence	 str	 tinylist	 tinytuple	 tup1	 tup2	 tup3	 tuple	 word	 
x	 y	 

元组索引，截取

L = ('spam', 'Spam', 'SPAM!')
L[2]        #读取第三个元素
L[-2]       #反向读取，读取倒数第二个元素
L[1:]       #截取元素

('Spam', 'SPAM!')

无关闭分隔符

任意无符号的对象，以逗号隔开，默认为元组。

元组内置函数

Python元组包含了以下内置函数：
cmp(tuple1, tuple2) 比较两个元组元素。
len(tuple) 计算元组元素个数。
max(tuple) 返回元组中元素最大值。
min(tuple) 返回元组中元素最小值。
tuple(seq) 将列表转换为元组。

Python 字典(Dictionary)

字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 ,分割，整个字典包括在花括号{}中 ,格式如下所示：

d = {
     key1 : value1, key2 : value2 }

键一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一。
值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。

dict = {
     'a': 1, 'b': 2, 'b': '3'}
print(dict['b'])
print(dict)

3
{'a': 1, 'b': '3'}

访问字典里的值

dict = {
     'Name': 'Zara', 'Age': 7, 'Class': 'First'}
 
print( "dict['Name']: ", dict['Name'])
print ("dict['Age']: ", dict['Age'])

dict['Name']:  Zara
dict['Age']:  7

修改字典

dict = {
     'Name': 'Zara', 'Age': 7, 'Class': 'First'}
 
dict['Age'] = 8 # 更新
dict['School'] = "RUNOOB" # 添加
 
 
print("dict['Age']: ", dict['Age'])
print("dict['School']: ", dict['School'])

dict['Age']:  8
dict['School']:  RUNOOB

删除字典元素

能删单一的元素也能清空字典，清空只需一项操作。

显示删除一个字典用del命令，如下实例：

dict = {
     'Name': 'Zara', 'Age': 7, 'Class': 'First'}
 
del (dict['Name'])  # 删除键是'Name'的条目
dict.clear()      # 清空字典所有条目
del(dict)        # 删除字典

print  ("dict['Age']: ", dict['Age'])
print ("dict['School']: ", dict['School'])

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

 in 
      5 del(dict)        # 删除字典
      6 
----> 7 print  ("dict['Age']: ", dict['Age'])
      8 print ("dict['School']: ", dict['School'])


TypeError: 'type' object is not subscriptable

字典键的特性

1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住
2）键必须不可变，所以可以用数字，字符串或元组充当，用列表就不行

dict = {
     'Name': 'Zara', 'Age': 7, 'Class': 'First'}
print("Equivalent String : %s" % str (dict))

Equivalent String : {'Name': 'Zara', 'Age': 7, 'Class': 'First'}

Python 日期和时间

Python 程序能用很多方式处理日期和时间，转换日期格式是一个常见的功能。

Python 提供了一个 time 和 calendar 模块可以用于格式化日期和时间。

时间间隔是以秒为单位的浮点小数。

每个时间戳都以自从1970年1月1日午夜（历元）经过了多长时间来表示。

Python 的 time 模块下有很多函数可以转换常见日期格式。如函数time.time()用于获取当前时间戳, 如下实例:

import time  # 引入time模块
 
ticks = time.time()
print ("当前时间戳为:", ticks)

当前时间戳为: 1602213121.0236251

时间戳单位最适于做日期运算。但是1970年之前的日期就无法以此表示了。太遥远的日期也不行，UNIX和Windows只支持到20-38年。

时间元组

序号	属性	值
0	tm_year	2008
1	tm_mon	1 到 12
2	tm_mday	1 到 31
3	tm_hour	0 到 23
4	tm_min	0 到 59
5	tm_sec	0 到 61 (60或61 是闰秒)
6	tm_wday	0到6 (0是周一)
7	tm_yday	1 到 366(儒略历)
8	tm_isdst	-1, 0, 1, -1是决定是否为夏令时的旗帜

获取当前时间

从返回浮点数的时间戳方式向时间元组转换，只要将浮点数传递给如localtime之类的函数。

localtime = time.localtime(time.time())
print ("本地时间为 :", localtime)

本地时间为 : time.struct_time(tm_year=2020, tm_mon=10, tm_mday=9, tm_hour=11, tm_min=23, tm_sec=50, tm_wday=4, tm_yday=283, tm_isdst=0)

获取格式化的时间

你可以根据需求选取各种格式，但是最简单的获取可读的时间模式的函数是asctime():

import time
 
localtime = time.asctime( time.localtime(time.time()) )
print ("本地时间为 :", localtime)

本地时间为 : Fri Oct  9 20:46:53 2020

获取某月日历

import calendar
 
cal = calendar.month(2016, 1)
print ("以下输出2016年1月份的日历:")
print(cal)

以下输出2016年1月份的日历:
    January 2016
Mo Tu We Th Fr Sa Su
             1  2  3
 4  5  6  7  8  9 10
11 12 13 14 15 16 17
18 19 20 21 22 23 24
25 26 27 28 29 30 31

Python 函数

定义一个函数

你可以定义一个由自己想要功能的函数，以下是简单的规则：

• 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
• 任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
• 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
• 函数内容以冒号起始，并且缩进。
• return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

# 定义函数
def printme( str ):
   "打印任何传入的字符串"
   print(str)
   return
 
# 调用函数
printme("我要调用用户自定义函数!")
printme("再次调用同一函数")

我要调用用户自定义函数!
再次调用同一函数

默认参数

调用函数时，默认参数的值如果没有传入，则被认为是默认值。下例会打印默认的age，如果age没有被传入：

#可写函数说明
def printinfo( name, age = 35 ):
   "打印任何传入的字符串"
   print ("Name: ", name)
   print ("Age ", age)
   return
 
#调用printinfo函数
printinfo( age=50, name="miki" )
printinfo( name="miki" )

Name:  miki
Age  50
Name:  miki
Age  35

不定长参数

你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述2种参数不同，声明时不会命名。基本语法如下：

# 可写函数说明
def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print("输出: ")
   print(arg1)
   for var in vartuple:
      print(var)
   return
 
# 调用printinfo 函数
printinfo( 10 )
printinfo( 70, 60, 50 )

输出: 
10
输出: 
70
60
50

匿名函数

python 使用 lambda 来创建匿名函数。

• lambda只是一个表达式，函数体比def简单很多。
• lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
• lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。
• 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2
 
# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))

相加后的值为 :  30
相加后的值为 :  40

return 语句

return语句[表达式]退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。之前的例子都没有示范如何返回数值，下例便告诉你怎么做：

# 可写函数说明
def sum( arg1, arg2 ):
   # 返回2个参数的和."
   total = arg1 + arg2
   print ("函数内 : ", total)
   return total
 
# 调用sum函数
total = sum( 10, 20 )

函数内 :  30

全局变量和局部变量

定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。

局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。如下实例：

total = 0 # 这是一个全局变量
# 可写函数说明
def sum( arg1, arg2 ):
   #返回2个参数的和."
   total = arg1 + arg2 # total在这里是局部变量.
   print("函数内是局部变量 : ", total)
   return total
 
#调用sum函数
sum( 10, 20 )
print("函数外是全局变量 : ", total)

函数内是局部变量 :  30
函数外是全局变量 :  0

str = input("请输入：")
print("你输入的内容是: ", str)

请输入：Hello Python!
你输入的内容是:  Hello Python!