Python3基础学习笔记

一、Python3 简介

Python 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。
Python 的设计具有很强的可读性，相比其他语言经常使用英文关键字，其他语言的一些标点符号，它具有比其他语言更有特色语法结构。

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

IDLE是什么？
IDLE是一个Python Shell，shell的意思就是“外壳”，就是一个通过键入文本与程序交互的途径！像我们Windows的cmd窗口，像Linux的命令窗口，他们都是shell，利用他们，我们就可以给操作系统下达命令，同样，我们可以利用IDLE这个shell与Python进行互动。

环境搭建

：

Anaconda

(下载途径一 官方地址：https://www.anaconda.com/download/
下载途径二 清华开源镜像站：https://mirrors.tuna.tsinghua.edu.cn/anaconda/archive/?C=M&O=D）

pycharm

（官方下载地址： https://www.jetbrains.com/pycharm/download/#section=windows）

二、Python3基础语法

1）python保留字

保留字即关键字，我们不能把它们用作任何标识符名称。Python 的标准库提供了一个 keyword 模块，可以输出当前版本的所有关键字

>>> import keyword
>>> keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

2）Python注释

Python中单行注释以 # 开头

>>> # 这是一个注释
>>> print("hello Pyhon！")
hello Pyhon！

多行注释用三个单引号 ‘’’ 或者三个双引号 “”" 将注释括起来

'''
这是多行注释，用三个单引号
这是多行注释，用三个单引号
这是多行注释，用三个单引号
'''
print("Hello, Python!")
"""
这是多行注释，用三个双引号
这是多行注释，用三个双引号
这是多行注释，用三个双引号
"""
print("Hello, World!")

Hello, Python!
Hello, World!

3）多个语句构成代码组

缩进相同的一组语句构成一个代码块，我们称之代码组。
像if、while、def和class这样的复合语句，首行以关键字开始，以冒号( : )结束，该行之后的一行或多行代码构成代码组。

if expression :
suite
elif expression :
suite
else :
suite

4）input键盘输入Print 输出

input 可以接收一个Python表达式作为输入，并将运算结果返回
input 输入的为字符串，如果想输入整形数字可用int(input())强制转换

>>> a = input("请输入：")
请输入：100
>>> print(a)
100
>>> type(a)
<class 'str'>

>>> b = int(input("请输入："))
请输入：100
>>> print(b)
100
>>> type(b)
<class 'int'>

print 默认输出是换行的，如果要实现不换行需要在变量末尾加上 end=" "

x = "a"
y = "b"

# 换行输出
print(x)
print(y)

print('*'*10)

# 不换行输出
print(x, end=" ")
print(y, end=" ")

a
b
**********
a b

str.format() 的使用：

括号及其里面的字符 (称作格式化字段) 将会被 format() 中的参数替换。在括号中的数字用于指向传入对象在 format() 中的位置

>>> print("{}：{}".format("Hello","Python"))
Hello：Python
>>> print("{name}网：{site}".format(name="淘宝",site="www.Taobao.com"))
淘宝网：www.Taobao.com

5）import 与 from…import

在 python 用 import 或者 from…import 来导入相应的模块。
将整个模块(somemodule)导入，格式为： import somemodule
从某个模块中导入某个函数,格式为： from somemodule import somefunction
从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc
将某个模块中的全部函数导入，格式为： from somemodule import *

>>> from math import sqrt
>>> print(sqrt(9))
3.0

三、Python3 基本数据类型

Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。
等号（=）用来给变量赋值，等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值。

a = 100      # 整型变量
b = 1000.0   # 浮点型变量
c = "abcde"  # 字符串

print(a)
print(b)
print(c)

100
1000.0
abcde

• 多个变量赋值，Python允许你同时为多个变量赋值

>>> a = b = c =3
>>> print(a,b,c)
3 3 3

• 多个对象指定多个变量

>>> a,b,c = 2,7,"Python"
>>> print(a,b,c)
2 7 Python

不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；

可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

1）Number（数字）

Python 支持三种不同的数值类型：

整型(Int)

- 通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用。

浮点型(float)

- 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）

复数( (complex))

- 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型

• Python 数字运算

>>> 5 + 4  # 加法
9
>>> 4.3 - 2 # 减法
2.3
>>> 3 * 7  # 乘法
21
>>> 2 / 4  # 除法，得到一个浮点数
0.5>>> 7 // 2 # 除法，得到一个整数
3
>>> 7 // 2.0  #注意：// 得到的并不一定是整数类型的数，它与分母分子的数据类型有关系。
3.0
>>> 17 % 3 # 取余
2
>>> 2 ** 5 # 乘方
32

2）Python3 字符串

Python中的字符串用单引号 ’ 或双引号 " 括起来，同时使用反斜杠 \ 转义特殊字符。

• 字符串的截取

变量[头下标：尾下标]

索引值以 0 为开始值，-1 为从末尾的开始位置。
加号 + 是字符串的连接符， 星号 * 表示复制当前字符串，与之结合的数字为复制的次数。

• Python字符串运算符

  
  下表实例变量a值为字符串 “Hello”，b变量值为 “Python”：
  

• 注意，Python 没有单独的字符类型，一个字符就是长度为1的字符串。

>>> str = "Hello Python"
>>> print(str)   #输出字符串
Hello Python
>>> print(str[0:-1])   #输出第一个到倒数第二个的所有字符
Hello Pytho
>>> print(str[0])      #输出字符串的第一个字符
H
>>> print(str[2:5])    #输出第三个开始到第五个的所有字符
llo
>>> print(str[2:])     #输出地三个开始后面的所有字符
llo Python
>>> print(str *2)      #输出字符串两次
Hello PythonHello Python
>>> print(str + "!!!!!") #连接字符串
Hello Python!!!!!
>>> if ("H" in str):
print("H 在变量str中")
H 在变量str中

• Python字符串格式化

  
  Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。

>>> print ("我叫 %s 今年 %d 岁!" % ('张三', 24))
我叫 张三 今年 24 岁!

• Python 的字符串内建函数

str.center(width[, fillchar])  #返回一个指定的宽度 width 居中的字符串，如果 width 小于字符串宽度直接返回字符串，否则使用 fillchar 去填充。

-width ：字符串的总宽度。
-fillchar ：填充字符。

>>> str = "[Hello Python]"
>>> print(str.center(40,"*"))
*************[Hello Python]*************

str.count(sub, start= 0,end=len(string)) #该方法返回子字符串在字符串中出现的次数

-sub ：搜索的子字符串
-start ： 字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0。
-end ： 字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置。

>>> str = "www.baidu.com"
>>> sub = "w"
>>> print("str.count('w'):",str.count(sub))
str.count('w'): 3

>>> sub = "baidu"
>>> print("str.count('baidu',0,13):",str.count(sub,0,13))
str.count('baidu',0,13): 1

str.find(str, beg=0, end=len(string))  #如果包含子字符串返回开始的索引值，否则返回-1

-str： 指定检索的字符串
-beg ： 开始索引，默认为0。
-end ： 结束索引，默认为字符串的长度。

>>> info = "abca"
>>> print(info.find('a')) # 从下标0开始，查找在字符串里第一个出现的子串，返回结果：0
0
>>> print(info.find('a',1)) # 从下标1开始，查找在字符串里第一个出现的子串：返回结果3
3
>>> print(info.find('3')) # 查找不到返回-1
-1

str.isalpha()  # 如果字符串至少有一个字符并且所有字符都是字母或文字则返回 True，否则返回 False。

>>> str = "HelloPython"
>>> print(str.isalpha())
True
>>> str = "abc张三"
>>> print(str.isalpha())
True
>>> str = "abc !!!"
>>> print(str.isalpha())
False

str.isdigit()  # 如果字符串只包含数字则返回 True 否则返回 False。

>>> str = "12345"
>>> print(str.isdigit())
True
>>> str = "abc111"
>>> print(str.isdigit())
False

str.isspace() # 如果字符串中只包含空格，则返回 True，否则返回 False.

>>> str = "    "
>>> print(str.isspace())
True
>>> str = "abc"
>>> print(str.isspace())
False

len( s )  # 返回对象长度。

>>> str = "Hello Python"
>>> len(str)
12
>>> list1 = [1,2,3,4]
>>> len(list1)
4

str.replace(old, new[, max])  # 返回字符串中的 old（旧字符串） 替换成 new(新字符串)后生成的新字符串，如果指定第三个参数max，则替换不超过 max 次。

-old ：将被替换的子字符串。
-new ：新字符串，用于替换old子字符串。
-max ：可选字符串, 替换不超过 max 次

>>> str = "www.baidu.com"
>>> print(str)
www.baidu.com
>>> print(str.replace("baidu","4399"))
www.4399.com

str.split(str="", num=string.count(str)) # 返回分割后的字符串列表。

-str ：分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。
-num ：分割次数。默认为 -1, 即分隔所有。

>>> str = "this is string example"
>>> print(str.split())   # 以空格为分隔符
['this', 'is', 'string', 'example']
>>> print(str.split('i',1)) # 以i为空格符
['th', 's is string example']

3）Python3 列表

List（列表） 是 Python 中使用最频繁的数据类型。
列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。
列表是写在方括号 [] 之间、用逗号分隔开的元素列表。
和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

• 列表的截取

  
  

>>> list1 = ["zbc",12,0.55,"张三","333"]
>>> list2 = [567,"李四"]
>>> print(list1)              #输出完整列表
['zbc', 12, 0.55, '张三', '333']
>>> print(list1[0])          #输出列表第1个元素
zbc
>>> print(list1[1:3])        #输出第2个元素开始到第3个元素
[12, 0.55]
>>> print(list1[2:])        #输出从第3个元素开始后面所有元素
[0.55, '张三', '333']
>>> print(list2 * 2)         #输出两次list2
[567, '李四', 567, '李四']
>>> print(list1 + list2)     #连接list1和list2
['zbc', 12, 0.55, '张三', '333', 567, '李四']

Python 列表截取可以接收第三个参数，参数作用是截取的步长，以下实例在索引 1 到索引 4 的位置并设置为步长为 2（间隔一个位置）来截取字符串：

• 列表推导式

  
  列表推导式提供了从序列创建列表的简单途径。通常应用程序将一些操作应用于某个序列的每个元素，用其获得的结果作为生成新列表的元素，或者根据确定的判定条件创建子序列。
  每个列表推导式都在 for 之后跟一个表达式，然后有零到多个 for 或 if 子句。返回结果是一个根据表达从其后的 for 和 if 上下文环境中生成出来的列表。如果希望表达式推导出一个元组，就必须使用括号。

>>> vec = [2, 4, 6]
>>> [3*x for x in vec]
[6, 12, 18]
>>> [[x, x**2] for x in vec]
[[2, 4], [4, 16], [6, 36]]

• Python3列表函数

  
  

>>> a = (3,7,-1,8,2,0,14)
>>> type(a)          #创建一个元组
<class 'tuple'>
>>> type(list(a))    #将元组转为列表
<class 'list'>
>>> len(list(a))     #求列表长度
7
>>> max(list(a))     #求列表中的最大值
14
>>> min(list(a))     #求列表中的最小值
-1

• Python3列表方法

list.append(obj) # 该方法无返回值，但是会修改原来的列表。

-obj ：添加到列表末尾的对象。

>>> list1 = ["Google","Taobao"]
>>> list1.append("Baidu")
>>> print(list1)
['Google', 'Taobao', 'Baidu']

list.count(obj) # 返回元素在列表中出现的次数。

-obj ：列表中统计的对象。

>>> list1 =[123,"Baidu",123,"Tianmao"]
>>> print(list1.count(123))
2
>>> print(list1.count("Tianmao"))
1

list.extend(seq) # 该方法没有返回值，但会在已存在的列表中添加新的列表内容。

-seq ：元素列表，可以是列表、元组、集合、字典，若为字典,则仅会将键(key)作为元素依次添加至原列表的末尾

>>> list1 = ["Google","Baidu"]
>>> list2 = list(range(6))
>>> list1.extend(list2)
>>> print(list1)
['Google', 'Baidu', 0, 1, 2, 3, 4, 5]

list.index(x[, start[, end]]) #该方法返回查找对象的索引位置，如果没有找到对象则抛出异常。

-x： 查找的对象。
-start： 可选，查找的起始位置。
-end： 可选，查找的结束位置。

>>> list1 = ["Baidu","Tianmao","Google"]
>>> print(list1.index("Tianmao"))
1
>>> print(list1.index("Google"))
2

list.insert(index, obj) # 该方法没有返回值，但会在列表指定位置插入对象。

-index ：对象obj需要插入的索引位置。
-obj ：要插入列表中的对象。

>>> list1 = ["Baidu","Tianmao","Google"]
>>> list1.insert(1,"4399")
>>> print(list1)
['Baidu', '4399', 'Tianmao', 'Google']

list.pop([index=-1]) # 该方法返回从列表中移除的元素对象。

-index ：可选参数，要移除列表元素的索引值，不能超过列表总长度，默认为 index=-1，删除最后一个列表值。

>>> list1 = ["Baidu","Tianmao","Google"]
>>> list1.pop()
'Google'
>>> list1.pop()
'Tianmao'
>>> print(list1)
['Baidu']

list.remove(obj) # 该方法没有返回值但是会移除列表中的某个值的第一个匹配项。

-obj：列表中要移除的对象。

>>> list1 = ["Baidu","Tianmao","Google"]
>>> list1.remove("Baidu")
>>> list1.remove("Google")
>>> print(list1)
['Tianmao']

list.reverse() # 该方法没有返回值，但是会对列表的元素进行反向排序。

>>> list1 = ["Baidu","Tianmao","Google","4399"]
>>> list1.reverse()
>>> print(list1)
['4399', 'Google', 'Tianmao', 'Baidu']

list.sort( key=None, reverse=False) # 该方法没有返回值，但是会对列表的对象进行排序。

-key ：主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
-reverse ：排序规则，reverse = True 降序， reverse = False 升序（默认）。

>>> list1 = ["Baidu","Tianmao","Google","4399"]
>>> list1.sort()
>>> print(list1)
['4399', 'Baidu', 'Google', 'Tianmao']

4）Python3 元组

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。

>>> tuple1 = ("zbc","123",567,0.33,"Baidu")
>>> tuple2 = (789,"Google")
>>> print(tuple1)
('zbc', '123', 567, 0.33, 'Baidu')
>>> print(tuple1[0])
zbc
>>> print(tuple1[1:3])
('123', 567)
>>> print(tuple1[2:])
(567, 0.33, 'Baidu')
>>> print(tuple1 * 2)
('zbc', '123', 567, 0.33, 'Baidu', 'zbc', '123', 567, 0.33, 'Baidu')
>>> print(tuple1 + tuple2)
('zbc', '123', 567, 0.33, 'Baidu', 789, 'Google')

>>> tup = (1,2,3,4,5)
>>> tup[0] = 9        # 修改元组元素的操作是非法的
Traceback (most recent call last):
File "<pyshell#146>", line 1, in <module>
tup[0] = 9
TypeError: 'tuple' object does not support item assignment

构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：

tup1 = ()    # 空元组
tup2 = (10,) # 一个元素，需要在元素后添加逗号

5）Python3 集合

集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。
基本功能是进行成员关系测试和删除重复元素。
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

sites = {'Google', 'Taobao', 'Runoob', 'Facebook', 'Zhihu', 'Baidu'}

print(sites)   # 输出集合，重复的元素被自动去掉
print("="*30)

# 成员测试
if 'Runoob' in sites :
print('Runoob 在集合中')
print("=" * 30)
else :
print('Runoob 不在集合中')
print("=" * 30)

# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')

print(a)
print("="*30)

print(a - b)     # a 和 b 的差集
print("="*30)

print(a | b)     # a 和 b 的并集
print("="*30)

print(a & b)     # a 和 b 的交集
print("="*30)

print(a ^ b)     # a 和 b 中不同时存在的元素
print("="*30)

{'Google', 'Zhihu', 'Runoob', 'Facebook', 'Taobao', 'Baidu'}
==============================
Runoob 在集合中
==============================
{'a', 'c', 'd', 'b', 'r'}
==============================
{'d', 'r', 'b'}
==============================
{'a', 'm', 'c', 'd', 'z', 'l', 'b', 'r'}
==============================
{'a', 'c'}
==============================
{'d', 'z', 'l', 'r', 'b', 'm'}
==============================

6）Python3 字典

字典（dictionary）是Python中另一个非常有用的内置数据类型。
列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。
键(key)必须使用不可变类型。
在同一个字典中，键(key)必须是唯一的。

dict = {}

dict["hello"] = "Python"
dict[2] = "www.Baidu.com"

tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}

print (dict['hello'])       # 输出键为 'hello' 的值
print("="*50)

print (dict[2])           # 输出键为 2 的值
print("="*50)

print (tinydict)          # 输出完整的字典
print("="*50)

print (tinydict.keys())   # 输出所有键
print("="*50)

print (tinydict.values()) # 输出所有值

Python
==================================================
www.Baidu.com
==================================================
{'name': 'runoob', 'code': 1, 'site': 'www.runoob.com'}
==================================================
dict_keys(['name', 'code', 'site'])
==================================================
dict_values(['runoob', 1, 'www.runoob.com'])

四、Python3条件控制

• if 嵌套

  
  -

  在嵌套 if 语句中，可以把 if...elif...else 结构放在另外一个 if...elif...else 结构中。

number = 7
guess = -1

print("数字猜谜游戏!")

while guess != number:
guess = int(input("请输入你猜的数字："))
if guess == number:
print("恭喜，你猜对了！")
elif guess < number:
print("猜的数字小了...")
elif guess > number:
print("猜的数字大了...")

数字猜谜游戏!
请输入你猜的数字：6
猜的数字小了...
请输入你猜的数字：8
猜的数字大了...
请输入你猜的数字：7
恭喜，你猜对了！

五、Python3循环语句

• while 循环

while 判断条件(condition)：
执行语句(statements)……

#求1-100之和
n = 100

sum = 0
count = 1

while count <= n:
sum = sum + count
count += 1

print("1 到 %d 之和为: %d" % (n, sum))

1 到 100 之和为: 5050

• while 循环使用 else 语句

  
  在 while … else 在条件语句为 false 时执行 else 的语句块。

count = 0

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

0  小于3
1  小于3
2  小于3
3  大于或等于 3

• for 语句

for <variable> in <sequence>:
<statements>
else:
<statements>

>>> x = [1,2,3,4,5,6]
>>> for i in x:
print(i,end = "")

123456

• range()函数

>>> a = ['Google', 'Baidu', 'Runoob', 'Taobao', 'QQ']
>>> for i in range(len(a)):
print(a[i])

Google
Baidu
Runoob
Taobao
QQ

• break 和 continue 语句及循环中的 else 子句

break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止，任何对应的循环 else 块将不执行。
continue 语句被用来告诉 Python 跳过当前循环块中的剩余语句，然后继续进行下一轮循环。`

for letter in 'Hello Python':   #使用break跳出循环
if letter == 'P':
break
print(letter,end = "")

Hello

for letter in 'www.Baidu.com':     #使用continue跳过当前循环
if letter == 'd':
continue
print (letter,end = "")

www.Baiu.com

六、Python3函数

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段

• 定义一个函数

def 函数名（参数列表）:
函数体

>>> def fun():
print("Hello Python")
>>> fun()
Hello Python

• 函数调用

  
  定义一个函数：给了函数一个名称，指定了函数里包含的参数，和代码块结构。
  这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从 Python 命令提示符执行。

def printme(str):        # 定义函数
print(str)           # 打印任何传入的字符串
return               # return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

printme("第一次调用函数")  # 调用函数

printme("第二次调用函数")

第一次调用函数
第二次调用函数

• 参数传递

  
  在 python 中，类型属于对象，变量是没有类型的

>>> a = [1,2,3]
>>> s = "Hello Python"

以上代码中，[1,2,3] 是 List 类型，“Hello Python” 是 String 类型，而变量 a 是没有类型，她仅仅是一个对象的引用（一个指针），可以是指向 List 类型对象，也可以是指向 String 类型对象。

在 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 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

# 可变对象在函数里修改了参数，那么在调用这个函数的函数里，原始的参数也被改变了
def change(_list):
_list.append([1, 2, 3, 4])
print("函数内取值: ", _list)
return

_list = [10, 20, 30]

change(_list)

print("函数外取值: ",_list)

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

# 不可变对象传值，这里只是新生成了一个int对象10，并用x指向它
def change(x):
x = 10
y = 5change(y)
print(y)

5

• 匿名函数

  
  python 使用 lambda 来创建匿名函数

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

# 例
sum = lambda a, b: a + b

print("相加后的值为 : ", sum(10, 20))
print("相加后的值为 : ", sum(2, 8))

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

• 函数参数：必需参数 关键字参数 默认参数 不定长参数

必需参数

：调用函数时的数量和顺序必须和声明时的一样，不然会出现语法错误：

>>> def fun(str):
print(str)
return

>>> fun("Hello Python")
Hello Python
>>> fun()              # 没有传入参数就会报错
Traceback (most recent call last):
File "<pyshell#43>", line 1, in <module>
fun()
TypeError: fun() missing 1 required positional argument: 'str'

关键字参数

：函数调用使用关键字参数来确定传入的参数值。

>>> def fun(name,site):
print("名字：",name)
print("网址：",site)
return

>>> fun(name = "淘宝",site = "www.taobao.com")
名字： 淘宝
网址： www.taobao.com

默认参数

：调用函数时，如果没有传递参数，则会使用默认参数。

>>> def fun(name,site = "www.taobao.com"):
print("名字：",name)
print("网址：",site)
return

>>> fun(name = "小游戏",site = "www.4399.com")
名字： 小游戏
网址： www.4399.com
>>> fun(name = "淘宝")
名字： 淘宝
网址： www.taobao.com

不定长参数

：当需要一个函数能处理比当初声明时更多的参数时，称这些参数叫做不定长参数，且声明时不会命名

>>> def fun(age,*p):
print(age)
print(p)
return

>>> fun(10,20,30,"Hello Python")
10
(20, 30, 'Hello Python')

七、Python3文件

• 读和写文件

open(filename, mode) # open() 将会返回一个 file 对象

-filename：包含了你要访问的文件名称的字符串值。
-mode：决定了打开文件的模式：只读，写入，追加等。

f = open("./t1.txt", "w")     # 打开一个文件，用"./"表示在当前路径下创建

f.write( "Python 是一个非常好的语言。\n是的，的确非常好!!\n" )

f.close()     # 关闭文件

# 打开文件t1.txt  显示如下
Python 是一个非常好的语言。
是的，的确非常好!!

• f.read()

  
  调用 f.read(size), 这将读取一定数目的数据, 然后作为字符串或字节对象返回，size 是一个可选的数字类型的参数。 当 size 被忽略了或者为负, 那么该文件的所有内容都将被读取并且返回。

f = open("./t1.txt", "r")   # 打开一个已创建文件

str = f.read()
print(str)

f.close()    # 关闭打开的文件

# 输出结果
Python 是一个非常好的语言。是的，的确非常好!!

• f.readline()

  
  f.readline() 会从文件中读取单独的一行。换行符为 ‘\n’。f.readline() 如果返回一个空字符串, 说明已经已经读取到最后一行。

f = open("./t1.txt", "r")    # 打开一个已创建文件

str = f.readline()
print(str)

f.close()   # 关闭打开的文件

# 输出结果
Python 是一个非常好的语言。

• f.readlines()

  
  f.readlines() 将返回该文件中包含的所有行。
  如果设置可选参数 sizehint, 则读取指定长度的字节, 并且将这些字节按行分割。

f = open("./t1.txt", "r")    # 打开一个已创建文件

str = f.readlines()
print(str)

f.close()  # 关闭打开的文件

['Python 是一个非常好的语言。\n', '是的，的确非常好!!\n'

另一种方式是迭代一个文件对象然后读取每行

f = open("./t1.txt", "r")   # 打开一个已创建文件

for line in f:
print(line, end='')

f.close()   # 关闭打开的文件

# 输出结果
Python 是一个非常好的语言。是的，的确非常好!!

• f.write()

  
  f.write(string) 将 string 写入到文件中, 然后返回写入的字符数。

f = open("./t2.txt", "w")     # 打开一个文件

num = f.write( "我爱Python,我爱人工智能" )
print(num)

f.close()   # 关闭打开的文件

# 输出结果
15

八、Python3面向对象

• -类 (Class):

类是用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。`

# 类的定义
class ClassName:
<statement_1>
.
.
.
<statement_N>

• 类对象

通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。
类对象支持两种操作：属性引用和实例化。

class Class_1:
i = 100

def fun(self):
return 'hello Python'

x = Class_1()   # 实例化类

# 访问类的属性和方法
print("Class_1 类的属性 i 为：", x.i)
print("Class_1 类的方法 fun 输出为：", x.fun())

Class_1 类的属性 i 为： 100
Class_1 类的方法 fun 输出为： hello Python

__init__()

为类的一个特殊方法（构造方法），该方法在类实例化时会自动调用，如果说（）里有参数，则参数通过 init() 传递到类的实例化操作上

class example:
def __init__(self, a, b):    # 用__init__构造，带参数，self 代表的是类的实例，代表当前对象的地址
self.x = a
self.y = b

z = example(-8, 25)

print(z.x, z.y)

-8 25

• 类的方法

在类的内部，使用 def 关键字来定义一个方法，类方法必须包含参数 self, 且为第一个参数，self 代表的是类的实例。

# 类定义
class people:
# 定义基本属性
name = ""
age = 0

# 定义构造方法
def __init__(self, n, a):
self.name = n
self.age = a

def speak(self):
print("%s 说: 我 %d 岁。" % (self.name, self.age))

# 实例化类
p = people('小明', 18)

p.speak()

小明 说: 我 18 岁。

• 继承

即一个派生类（derived class）继承基类（base class）的字段和方法。

# 类定义
class example:
# 定义基本属性
name = ''
age = 0

# 定义构造方法
def __init__(self, n, a):
self.name = n
self.age = a

def speak(self):
print("%s 说: 我 %d 岁。" % (self.name, self.age))

class student(example):
grade = ''

def __init__(self, n, a, g):
# 调用父类的构造方法
example.__init__(self, n, a)
self.grade = g

# 覆写父类的方法
def speak(self):
print("%s 说: 我 %d 岁了，我在读 %d 年级" % (self.name, self.age, self.grade))

s = student('小明', 18, 3)
s.speak()

小明 说: 我 18 岁了，我在读 3 年级

九、Python3 命名空间和作用域

• 命名空间

命名空间(Namespace)是从名称到对象的映射，各个命名空间是独立的，没有任何关系的，所以一个命名空间中不能有重名，但不同的命名空间是可以重名而没有任何影响。
一般有三种命名空间：

内置名称（built-in names）

， Python 语言内置的名称，比如函数名 abs、char 和异常名称 BaseException、Exception 等等。

全局名称（global names）

，模块中定义的名称，记录了模块的变量，包括函数、类、其它导入的模块、模块级的变量和常量。

局部名称（local names）

，函数中定义的名称，记录了函数的变量，包括函数的参数和局部定义的变量。（类中定义的也是）

a = 5              # a 是全局名称
def fun():
b = 6          # b 是局部名称
def fun1():
c = 7      # c 是内嵌的局部名称

• 作用域

作用域就是一个 Python 程序可以直接访问命名空间的正文区域，Python 中，程序的变量并不是在哪个位置都可以访问的，访问权限决定于这个变量是在哪里赋值的。

变量的作用域决定了在哪一部分程序可以访问哪个特定的变量名称

Python 中只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域，其它的代码块（如 if/elif/else/、try/except、for/while等）是不会引入新的作用域的，也就是说这些语句内定义的变量，外部也可以访问

规则顺序：在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内置中找

a = 0                # 全局作用域
def fun1():
b = 1            # 闭包函数外的函数中
def fun2():
v = 2        # 局部作用域

• 全局变量和局部变量

定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。
局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。

sum = 0                 # sum这是一个全局变量

def fun(a, b):
sum = a + b        # sum在这里是局部变量.
print("函数内是局部变量 : ", sum)
return sum

fun(4, 6)
print("函数外是全局变量 : ", sum)

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

• global 和 nonlocal关键字

当内部作用域想修改外部作用域的变量时，就需要用到global和nonlocal关键字

a = 1
def fun():
global a    # 需要使用 global 关键字声明
print(a)
a = 100
print(a)

fun()

print(a)

1
100
100

如果要修改嵌套作用域（enclosing 作用域，外层非全局作用域）中的变量则需要 nonlocal 关键字

def fun1():
a = 10
def fun2():
nonlocal a   # nonlocal关键字声明
a = 50
print(a)
fun2()
print(a)
fun1()

50
50

转载于：https://m.runoob.com/python3/