Python基础笔记

一、python基础
1.1 基础知识
1.1.1 注释
注释：在程序中对程序代码进行解释说明的文字。
作用：注释不是程序，不能被执行，只是对程序代码进行解释说明，让别人可以看懂程序代码的作用，能够大大增强程序的可读性。

单行注释：以  #开头，#右侧 的所有文字当做说明，而不是真正要执行的程序，起辅助说明作用；
多行注释：以一对三个双引号引起来（“”“注释内容”“”）来解释说明一段代码的作用使用方法，多行注释可以换行。

1.1.2 转义字符

# 转义字符
print('hello\nworld') #\n换行
print('hello\tworld') #\t制表符
print('helloo\tworld')
print('hello\rworld') #\r回车
print('hello\bworld') #\b回退一格，将o回退了
print('www:\\\\baidu.com')
print('老师说：\'asda\'')

# 原字符，不希望字符串中的转义字符起作用就可以使用原字符，就是在字符串之首加上r或者R
print(r'hello\nworld`')

1.1.3 关键字
下面的列表显示了在Python中的保留字。这些保留字不能用作常数或变数，或任何其他标识符名称。

所有 Python 的关键字只包含小写字母。

1.1.4 标识符
在python中我们可以给很多的东西起名字，如变量名、方法名、类名等等这些统称为标识符

1.2 python中常用的数据类型

1.3 变量
变量：在程序运行时，能存储计算结果或能表示值的抽象概念。
变量定义的格式： 变量名称=变量值
变量的特征：变量的值是可以改变的

1.3.1 查看变量的类型type()
通过type(变量)查看的是变量中存储的数据的类型。因为变量无类型，但它存储的数据有类型。

在print语句中直接输出类型信息，如下代码所示
用变量存储type()的结果(返回值)

name = '张三'
print(name)#张三
print('标识',id(name))#标识 1927861047728
print('类型',type(name))#类型 <class 'str'>
print('值',name)#值 张三


name = '赵六'
print(name)#赵六
print('标识',id(name))#标识 1927862147856
print('类型',type(name))#类型 <class 'str'>
print('值',name)#值 赵六


name = 333
print(name)#333
print('标识',id(name))#标识 1927861828912
print('类型',type(name))#类型 <class 'int'>
print('值',name)#值 333

name = name-111
print(name)#222
print('标识',id(name))#标识 2432928146768
print('类型',type(name))#类型 <class 'int'>
print('值',name)#值 222

name = '王五'
print(name)#王五
print('标识',id(name))#标识 1927862148240
print('类型',type(name))#类型 <class 'str'>
print('值',name)#值 王五

1.3.2 数据类型转换
数据类型之间，在特定的场景下，是可以相互转换的，比如字符串转数字、数字转字符串等

name = '张三'
age = 20

# 使用str()函数将age由int类型转为 str类型输出
print('我叫' + name + "今年" + str(age) + '岁')#我叫张三今年20岁

print('-----------------str()将其他类型转为str类型-----------')
a = 10
b = 198.8
c = False
print(type(a), type(b), type(c))#<class 'int'> <class 'float'> <class 'bool'>
print(str(a), str(b), str(c), type(str(a)), type(str(b)), type(str(c)))#10 198.8 False <class 'str'> <class 'str'> <class 'str'>

print('-----------------int()将其他类型转为int类型-----------')
s1 = "111"
s2 = 98.7  # 这个转为int类型会丢失小数点后边的内容
s3 = False
s4 = "99.2"  # 字符串为小数，没办法转为int类型
print(type(s1), type(s2), type(s3), type(s4))#<class 'str'> <class 'float'> <class 'bool'> <class 'str'>
print(int(s1), int(s2), int(s3), type(int(s1)), type(int(s2)), type(int(s3)))#111 98 0 <class 'int'> <class 'int'> <class 'int'>

print('-----------------float()将其他类型转为float类型-----------')
f1 = "111"
f2 = 98.7
f3 = False
f4 = "99.2"
print(type(f1), type(f2), type(f3), type(f4))#<class 'str'> <class 'float'> <class 'bool'> <class 'str'>
print(float(f1), float(f2), float(f3), float(f4), type(float(f1)), type(float(f2)), type(float(f3)), type(float(f4)))#111.0 98.7 0.0 99.2 <class 'float'> <class 'float'> <class 'float'> <class 'float'>

1.4 字符串
字符串（string），又称文本，是由任意数量的字符如中文、英文、各类符号、数字组成。所以叫做字符的串。
在python中，字符串需要用双引号包括起来

print(510)
print(98.2)

# 输出字符串
print('helloWord')
print("helloWord")

# 输出到文件
fb = open('D:/test.txt', 'a+') # a+ 如果文件不存在则创建，如果存在则追加
print('helloworld', file=fb)
fb.close()

# 不换行输出
print('hello','word','python')

1.4.1 字符串的三种定义方式

1.4.2 字符串拼接
如果我们有两个字符串（文本）字面量，可以将其拼成一个字符串，通过+号即可完成，如：print(‘张’+‘三’) #张三1.4.3 字符串格式化

'''
类型码
%s 字符串
%d 整数
%f 浮点数  %.1f保留一位小数 %.2f保留两位小数
'''

a = 1
b = 2
print("在这里我们打印ab的，a:"+str(a)+",b:"+str(b))#在这里我们打印ab的，a:1,b:2

# 字符串格式化
str1 = "在这里我们打印ab的值，a:%s,b:%s" % (str(a), str(b))
print(str1)#在这里我们打印ab的值，a:1,b:2

print("在这里我们打印ab的值，a:%s,b:%s" % (str(a), str(b)))#在这里我们打印ab的值，a:1,b:2
print("在这里我们打印ab的值，a:%d,b:%d" % (a,b))#在这里我们打印ab的值，a:1,b:2
print("在这里我们打印ab的值，a:%.1f,b:%.2f" % (10.55, 10.55))#在这里我们打印ab的值，a:10.6,b:10.55

1.4.4 格式化精度控制

1.4.5 字符串格式化方式2
通过语法：f"内容{变量}"的格式来快速格式化

a = 1
b = 2
print(f"在这里我们打印ab的值，a:{a},b:{b}" )#在这里我们打印ab的值，a:1,b:2

这种快速格式化的方法不限制类型，不进行精度控制，适合对精度没有要求的时候快速使用

1.5 运算符
1.5.1 算数运算符与赋值运算符
算数运算符：

**赋值运算符：** 

print('加法运算', 1 + 1)
print('减法运算', 2 - 1)
print('乘法运算', 2 * 3)
print('除法运算', 9 / 3)
print('取整运算', 9 // 4)
print('取余运算', 9 % 4)
print('幂运算', 3 ** 3)

print(9 // 4)  # 2
print(-9 // -4)  # 2
# 一正一负取整都是向下取整
print(-9 // 4)  # -3
print(9 // -4)  # -3


print(9 % 4)  # 1
print(-9 % -4)  # -1
print(-9 % 4)  # 3
print(9 % -4)  # -3


a = 10
a+=2
print(a)
a-=2
print(a)
a*=2
print(a)
a/=2
print(a)
a//2
print(a)
a%=4
print(a)
a*=2
print(a)

1.5.2 比较运算符与身份运算符
比较运算符：

我们可以通过比较运算符，计算得到布尔类型的结果

身份运算符：

'''
< > == <= >= 省略
'''

a=10
b=10
c=3
print(a==b) #True,说明a与b的value相等
print(a>c) #True
print(c>b) #False
print(a is b) #True，说明a与b的标识，相等

list1=[11,22,33]
list2=[11,22,33]
print(list1==list2) #True
print(list1 is list2) #False
print(list1 is not  list2) #True 这里的意思是list1与list2的id不相等，不相等为True

1.5.3 逻辑运算符

a, b = 1, 2
print(a == 1 and b == 2)#True
print(a == 1 and b < 2)#False
print(a != 1 and b == 2)#False
print(a == 1 or b == 1)#True

print(not a == 1)#False

1.5.4 成员运算符：

print('----------------in与not in------------')
s = "hello world"
print("h" in s)  # h 是否存在于变量s中 True
print("k" in s)#False

print("k" not in s)  # k 是否不存在于变量s中  True

1.5.5 位运算符
按位运算符是把数字看作二进制来进行计算的

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
a = 60            # 60 = 0011 1100 
b = 13            # 13 = 0000 1101 
c = 0
 
c = a & b;        # 12 = 0000 1100
print("1 - c 的值为：", c)
 
c = a | b;        # 61 = 0011 1101 
print("2 - c 的值为：", c)
 
c = a ^ b;        # 49 = 0011 0001
print("3 - c 的值为：", c)
 
c = ~a;           # -61 = 1100 0011
print("4 - c 的值为：", c)
 
c = a << 2;       # 240 = 1111 0000
print("5 - c 的值为：", c)
 
c = a >> 2;       # 15 = 0000 1111
print("6 - c 的值为：", c)

#输出结果
#1 - c 的值为： 12
#2 - c 的值为： 61
#3 - c 的值为： 49
#4 - c 的值为： -61
#5 - c 的值为： 240
#6 - c 的值为： 15

1.5.6 运算符优先级

1.6 数据输入
使用input()语句可以从键盘获取输入，使用一个变量结合搜input语句获取的键盘输入内容即可
注意点： 无论键盘输入什么类型的数据，获取道德数据永远都是字符串类型

present = input('大圣想要什么礼物呢？')
print(present, type(present))

a = input("请输入第一个数")
b = input("请输入第二个数")
print('a+b=',int(a)+int(b))

c = int(input("请输入第一个数"))
d = int(input("请输入第二个数"))
print('c+d=',c+d)

大圣想要什么礼物呢？aaa
aaa<class 'str'>
请输入第一个数1
请输入第一个数2
a+b= 3
请输入第一个数3
请输入第一个数4
c+d =7

1.7 流程控制
1.7.1 分支结构
1.7.1.1 if、if else、if elif else语句
if语法：
if 要判断的条件：
        条件成立时要做的事情

if else 语句

if elif else语句

moeny = 1000
s = int(input('请输入取款金额'))

if moeny >= s:
    moeny -= s
    print('取款成功')
else:
    print('取款失败，余额不足')



'''-----------------多if-----------------------'''

s1 = int(input('请输入月份'))
if s1 > 0 and s1 <= 3:
    print("春天")
elif s1 > 3 and s1 <= 6:
    print('夏天')
elif s1 > 6 and s1 <= 9:
    print('秋天')
elif s1 > 9 and s1 <= 12:
    print("冬天")
else:
    print("不存在该月份")

1.7.1.2 if判读语句的嵌套

num1 =int(input("请输入会员积分"))
if num1>50:
    print('是会员')
    if num1>=200 :
        print("八折")
    else:
        if num1>100:
            print("9折")
        else:
            print("9.5折")
else:
    print('不是会员')

1.7.2 循环控制
1.7.2.1 while循环

while 判断条件(condition)：
        执行语句(statements)……
执行过程如下：

while循环的注意事项：条件需提供布尔类型结果，True继续，False停止
空格缩进不能忘
请规划好循环终止条件，否则将无限循环

a =10 #定义三角形的宽度和高度
while a>=1 :
    b =a
    while b>=1:
        print('*', end="")
        b-=1
    print('')
    a-=1

#  运行结果
# **********
# *********
# ********
# *******
# ******
# *****
# ****
# ***
# **

1.7.2.2 使用while嵌套循环打印九九乘法表

for a in range(1, 10):
    for b in range(1, 10):
        if b <= a:
            print(b, "x", a, "=", a * b, end="   ")
    print("")

1.7.2.3 for循环

#语法结构
for iterating_var in sequence:
   statements(s)

#示例
list1 =range(1,100)
for a in list1 :
    print(a)

sum = 0
for b in range(1,101) :
    sum+=b

print(sum)


fruits = ['banana', 'apple',  'mango']
for index in range(len(fruits)):
   print ('当前水果 : %s' % fruits[index])
 
print ("Good bye!")
#运行结果
#当前水果 : banana
#当前水果 : apple
#当前水果 : mango
#Good bye!

1.7.2.4 range

for循环语句，本质上是遍历：序列类型
语法：

range(num)，获取一个从0开始，到num结束的数字序列(不含num本身)，如range(5)，取得的数据室[0,1,2,3,4]
range(num1,num2)，获得一个从num1开始，到num2结束的数字序列(不含num2本身)，如range(5，10)，取得的数据室[5,6,7,8,9]
range(num1,num2,step)，获取一个从num1开始，到num2结束的数字序列(不含num2本身)，数字之间的步长，以step为准（step默认为1）,如range(5,10,2)取得的数据为：[5,7,9]
示例：

#range()的三种创建方式

'''第一种创建方式，只有一个参数'''
r =range(10) #默认从0开始，默认相邻两个数相差1，即步长为1
print(r)  #range(0, 10)
print(list(r))  #list可以用于查看range对象中的整数序列  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

'''第二种创建方式，给了两个参数，第一个是 起始位置 ，第二个为结束位置'''
r =range(1,10)
print(list(r)) #[1, 2, 3, 4, 5, 6, 7, 8, 9]

'''第三种创建方式，给了三个参数，起始位置、结束位置、步长'''
r =range(1,10,2)
print(list(r)) #[1, 3, 5, 7, 9]

#判断指定的整数在序列中是否存在
print(10 in r) #10不在当前的整数序列
print(9 in r) #9在当前的序列中
print(10 not in r) #10不在当前的整数序列
print(9  not in r) #9在当前的序列中

小练习：

# 练习：随机产生两个数字，计算其总和
# 一道题10分，总计30分，计算总成绩

import random
from turtle import st

successCount = 0  # 答对次数


for item in range(0, 3):
    print("第", item, "题")
    # 产生两个随机数
    num1 = random.randint(0, 100)
    num2 = random.randint(0, 100)
    inputNum = int(input('请输入 '+str(num1)+'+'+str(num2)+' 的结果'))
    if inputNum == num1+num2:
        print('恭喜你答对了')
        successCount+=1
    else:
        print('很遗憾，计算错误')

    print("")

print('您一共答对了 ', successCount, " 道题，总分：", successCount*10, "分")

1.7.2.5 break 语句
Python break语句，就像在C语言中，打破了最小封闭for或while循环。
break语句用来终止循环语句，即循环条件没有False条件或者序列还没被完全递归完，也会停止执行循环语句。
break语句用在while和for循环中。
如果您使用嵌套循环，break语句将停止执行最深层的循环，并开始执行下一行代码。

示例：

for letter in 'Python':     # 第一个实例
   if letter == 'h':
      break
   print('当前字母 :', letter)
  
var = 10                    # 第二个实例
while var > 0:              
   print('当前变量值 :', var)
   var = var -1
   if var == 5:   # 当变量 var 等于 5 时退出循环
      break
 
print("Good bye!")

#运行结果：
#当前字母 : P
#当前字母 : y
#当前字母 : t
#当前变量值 : 10
#当前变量值 : 9
#当前变量值 : 8
#当前变量值 : 7
#当前变量值 : 6
#Good bye!

1.7.2.6 continue 语句
Python continue 语句跳出本次循环，而break跳出整个循环。
continue 语句用来告诉Python跳过当前循环的剩余语句，然后继续进行下一轮循环。
continue语句用在while和for循环中。

示例：

for letter in 'Python':     # 第一个实例
   if letter == 'h':
      continue
   print('当前字母 :', letter)
 
var = 10                    # 第二个实例
while var > 0:              
   var = var -1
   if var == 5:
      continue
   print('当前变量值 :', var)
print("Good bye!")

#运行结果
#当前字母 : P
#当前字母 : y
#当前字母 : t
#当前字母 : o
#当前字母 : n
#当前变量值 : 9
#当前变量值 : 8
#当前变量值 : 7
#当前变量值 : 6
#当前变量值 : 4
#当前变量值 : 3
#当前变量值 : 2
#当前变量值 : 1
#当前变量值 : 0
#Good bye!

1.8 函数
函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。
函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。

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

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

def functionname( parameters ):
   "函数_文档字符串"
   function_suite
   return [expression]

默认情况下，参数值和参数名称是按函数声明中定义的顺序匹配起来的。

函数调用
定义一个函数只给了函数一个名称，指定了函数里包含的参数，和代码块结构。

这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从Python提示符执行。

如下实例调用了printme（）函数：

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

1.8.2 函数的参数传递
在 python 中，类型属于对象，变量是没有类型的：

a=[1,2,3]
a="Runoob"

以上代码中，[1,2,3] 是 List 类型，“Runoob” 是 String 类型，而变量 a 是没有类型，她仅仅是一个对象的引用（一个指针），可以是 List 类型对象，也可以指向 String 类型对象。
可更改(mutable)与不可更改(immutable)对象
在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。
可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。
python 函数的参数传递：

不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响
python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

::: tip
python 传不可变对象实例与传可变对象实例这点一定要区分清楚
:::
传不可变对象实例

def ChangeInt( a ):
    a = 10
 
b = 2
ChangeInt(b)
print b # 结果是 2

实例中有 int 对象 2，指向它的变量是 b，在传递给 ChangeInt 函数时，按传值的方式复制了变量 b，a 和 b 都指向了同一个 Int 对象，在 a=10 时，则新生成一个 int 值对象 10，并让 a 指向它。

传可变对象实例

# 可写函数说明
def changeme( mylist ):
   "修改传入的列表"
   mylist.append([1,2,3,4])
   print("函数内取值: ", mylist)
   return
 
# 调用changeme函数
mylist = [10,20,30]
changeme( mylist )
print("函数外取值: ", mylist)

实例中传入函数的和在末尾添加新内容的对象用的是同一个引用，故输出结果如下：

函数内取值:  [10, 20, 30, [1, 2, 3, 4]]
函数外取值:  [10, 20, 30, [1, 2, 3, 4]]

1.8.2.1 必备参数
必备参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
调用printme()函数，你必须传入一个参数，不然会出现语法错误：

#可写函数说明
def printme( str ):
   "打印任何传入的字符串"
   print str
   return
 
#调用printme函数
printme()

以上实例输出结果：

Traceback (most recent call last):
  File "test.py", line 11, in <module>
    printme()
TypeError: printme() takes exactly 1 argument (0 given)

1.8.2.2 关键字参数
关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。
使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。
以下实例在函数 printme() 调用时使用参数名：

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

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

#以上实例输出结果：
#Name:  miki
#Age  50

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

def printinfo( name, age = 35 ):#这里在定义函数的时候给age设置默认值
   "打印任何传入的字符串"
   print("Name: ", name)
   print("Age ", age)
   return
 
#调用printinfo函数
printinfo( age=50, name="miki" )
printinfo( name="miki" )

#以下为实例结果
#Name:  miki
#Age  50
#Name:  miki
#Age  35

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

def functionname([formal_args,] *var_args_tuple ):
   "函数_文档字符串"
   function_suite
   return [expression]

加了星号（*）的变量名会存放所有未命名的变量参数。不定长参数实例如下：

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

1.8.2.5 双星号传参

# 双星号传参，可以传递无数的关键字实参
def fun2(**a):
    print(a)
fun2(a=1,b=2,c=3) 
#输出结果{'a': 1, 'b': 2, 'c': 3}

1.8.2.6 将函数作为参数传递
在python中，函数是可以作为参数传递给其他函数的

def test_func(compute):
    result = compute(1,2)
    print(f"compute的参数类型是：{type(compute)}")
    print(f"计算结果：{result}")

def compute(x,y):
    return  x+y

test_func(compute)

执行结果

compute的参数类型是：<class 'function'>
计算结果：3

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

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

lambda [arg1 [,arg2,.....argn]]:expression

如下实例：

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

#以下为输出结果
#相加后的值为 :  30
#相加后的值为 :  40

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

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

#以上实例输出结果：
#函数内 :  30
#函数外 :  30

1.8.4.1 函数多返回值
函数可以定义多个返回值，return多个值即可，返回的多个结果可以通过索引取出对应位置的值

def multi_return():
    return_tuple = ('张三', 12)
    return return_tuple
def multi_return2():
    return '张三', 12
print(multi_return())
result = multi_return2()
print('multi_return2返回值是=,类型是=', result, type(result))
print( result[0])
print( result[1])

以上代码返回结果

('张三', 12)
multi_return2返回值是=,类型是= ('张三', 12) <class 'tuple'>
张三
12

1.8.5 变量作用域
两种最基本的变量作用域：全局变量和局部变量

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

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

#以上实例输出结果：
#函数内是局部变量 :  30
#函数外是全局变量 :  0

g01 = "yes"
g03="bbb"
print(g01)


def fun1():
    # 在函数中可以读取到全局变量
    print(g03)

    # 创建一一个局部变量g01，而不是修改全局变量
    # g01="no"

    # 通过global定义全局变量g01
    # 修改全局变量
    global g01
    g01="no"
    print(g01)

    global  g02
    g02="aaaa"

fun1()
print(g01)
print(g02)

1.8.6 函数的说明文档
对函数进行必要的的注释方便后期调用和维护，我们通常在函数内部使用多行注释标明函数的作用和所需参数以及返回值

1.9 容器类通用
索引和切片

str1= "我是大阿达的开始就阿卡"

# 索引
print(str1[1])#获取第二个字符
print(str1[2])#获取第三个字符

# 切片
# 从容器中取出相应位置的元素
# 语法： 容器[:开始索引，:结束索引，:步长]

# 开始索引默认为0
print(str1[:8])
# 指定开始索引
print(str1[3:])
# 指定开始索引和结束索引
print(str1[1:8])
# 指定开始索引、结束索引和步长
print(str1[1:8:2])
# 指定从容器尾部开始，所以为负数
print(str1[-1:-8:-1])
# 从尾部向前输出
print(str1[::-1])

以上代码输出结果：
是
大
我是大阿达的开始
阿达的开始就阿卡
是大阿达的开始
是阿的始
卡阿就始开的达
卡阿就始开的达阿大是我

1.10 列表List
序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。

Python有6个序列的内置类型，但最常见的是列表和元组。

序列都可以进行的操作包括索引，切片，加，乘，检查成员。

此外，Python已经内置确定序列的长度以及确定最大和最小的元素的方法。

列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。

列表的数据项不需要具有相同的类型

创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：

list1 = ['physics', 'chemistry', 1997, 2000]
list2 = [1, 2, 3, 4, 5 ]
list3 = ["a", "b", "c", "d"]

#输出结果
#list1[0]:  physics
#list2[1:5]:  [2, 3, 4, 5]

1.10.1 列表的增删改操作

# 列表

# 1、创建列表
list1 = []
list2 = list()

# 默认值
list3 = ["张安", "李四", "王五"]
list4 = list("赵六孙琪大圣")

# 索引
print(list3[2])
print(list4[2])
# 切片
print(list3[:1])
print(list4[::-1])

# 添加元素
print(list3)
list3.append("老刘")
print(list3)

# 在指定位置添加元素
print(list3)
list3.insert(1, True)
list3.insert(1, 333)
print(list3)

# 删除元素
# 根据元素删除
print(list3)
list3.remove("张安")
print(list3)
# 根据索引删除，索引位置可以使用切片
del list3[2]
del list3[3:]
print(list3)


# 定义元素，目的：可以增删改查元素
# 删除
print(list4)
del list4[1:2]
print(list4)

# 修改
list4[1:2] = ['a', 'b']
print(list4)
list4[1:2] = []
print(list4)


# 遍历列表
for item in list3:
    print(item)

# 倒叙遍历列表
# 不建议使用切片倒叙列表
for item in list3[::-1]:
    print(item)

# 倒叙遍历列表
# 建议使用range函数
for item in range(len(list3)-1, -1, -1):
    print(list3[item])

1.10.2 列表脚本操作符

1.10.3 Python列表函数&方法

1.10.4 列表推导式

使用推导式可以一定程度上简化代码

# 列表推导式
list01=[item for item in range(1,20)]
print(list01)#[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

1.10.5 列表与字符串
列表与字符串是可以相互转换的：

join()可以将列表转化为字符串

split()可以将字符串,按指定分隔符转化为list

list1=[]
for item in range(0,10):
    list1.append(str(item))

# join可以将列表转化为字符串
# join前边得是连接符 
print("-".join(list1))
print("".join(list1))

str1="张三-李四-王五-赵六"
list2=str1.split("-")
print(list2)

1.10.6 小练习
随机生成一注彩票，再随机买票，看看需要多久才能中奖

from ntpath import join
import random
import operator


# 创建彩票得方法
def createCaipiao():
    list1 = []
    while len(list1) < 7:
        # 生成六个红球，一个篮球
        if(len(list1) == 6):
            # 生成篮球
            num1 = random.randint(1, 16)
            list1.append(num1)
        else:
            # 生成红球
            num1 = random.randint(1, 34)
            if(num1 not in list1):
                list1.append(num1)
    return list1


# 生成一注彩票
list1 = createCaipiao()

# 通过循环生成彩票看看中奖需要多久
# 每注彩票2元
money = 0

while True:
    list2 = createCaipiao()
    if(operator.eq(list1, list2)):
        print("恭喜您中奖了，共买了%d注彩票，共花费%d元，中奖号码是%s" %
              (money/2, money,  str(list2)))
        break
    else:
        money += 2
        print("第%d注，号码为：%s" % (money/2, str(list2)))
        if money/2 > 100000:
            print("我放弃了")
            break

1.11 元组
Python 的元组与列表类似，不同之处在于元组的元素不能修改。

元组使用小括号，列表使用方括号。

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d"

创建空元组

tup1 = ()

元组中只包含一个元素时，需要在元素后面添加逗号

tup1 = (50,)

1.11.1 元组的增删改操作

# 1、创建元组
tuple01=()#空元组
tuple01=(1,2,3)#具有默认值

print(tuple01)

# 列表-》元组
tuple01=tuple(["a","b"])
print(tuple01)

# 元组-》列表
list01=list(tuple01)
print(list01)

# 如果元组只有一个元素，需要加逗号
tuple02=(2,)
print(type(tuple02))#int

# 2、获取元素
tuple03=("a","b","c","d","e")
print(tuple03[1])
print(tuple03[3])
print(tuple03[-2:])
print(tuple03[1:4:2])

tuple04=("a","b")
a,b=tuple04
print(a)
print(b)


# 3、遍历元素
for item in tuple03:
    print(item)

print("-------------------")


for item in range(len(tuple03)-1,-1,-1):
    print(tuple03[item])

1.11.2 元组运算符

1.11.3 元组内置函数