Python复习 一

Python回炉复习 1

变量

Python的变量和C语言的变量书写方式类似；

书写要求

python程序编写结构利用缩进表示，抛弃花括号；

结构

分支：

if(条件语句1):
    执行语句块
else if(条件语句2):
    执行语句块
else:
    执行语句块

循环：

while 循环

while 循环条件:
    循环语句体

for 循环

for 目标 in 表达式：
    循环语句体

表达式的结果会和目标联成共体

  • range()函数：

步长函数；

range(x,y,z)

? x：开始

? y：结束（y-1）

? z：步长

  • break 语句：

跳出当前结构体

  • continue 语句：

结束以此循环体的运行

列表

创建列表

>>> num = [1,2,3,4,5] // 列表创建
>>> num               // 列表输出
[1, 2, 3, 4, 5]
>>> num = ['Hello','你好',666]
>>> num // 列表支持各种类型，除数字以外的其他字符都需要用单引号
['Hello', '你好', 666]

append()：添加元素

>>> num.append(6)
>>> num
[1, 2, 3, 4, 5, 6]

extend()：添加多个元素

>>> num.extend([7,8,9])
>>> num
[1, 2, 3, 4, 5, 6, 7, 8, 9]

append()是添加一个单独的元素，就是简单的扩充；

而extend()则是将原有的列表和自己要添加的列表拼接成一个新列表

insert()：在列表中插入元素

>>> num.insert(0,0) // 在0索引位置添加元素0
>>> num
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

pop()：删除列表元素

  • php()：删除列表最后一个元素
  • php(X)：删除列表中索引为X的元素
  • pop()会返回被删除的元素内容
>>> num.pop()
9
>>> num.pop(0)
0
>>> num
[1, 2, 3, 4, 5, 6, 7, 8]

del 语句：删除列表

  • del [ListName]：删除整个列表（也可以同时删除多个）
  • del [ListName[X]]：删除索引为X的元素
>>> num = [1,2,3,4,5,6,7,8]
>>> num
[1, 2, 3, 4, 5, 6, 7, 8]
>>> del num[7]
>>> num
[1, 2, 3, 4, 5, 6, 7]
>>> del num
>>> num
Traceback (most recent call last):
  File "<pyshell#19>", line 1, in <module>
    num
NameError: name 'num' is not defined

如报错提示：num不存在

remove()：删除已知X元素

  • 搜索元素X内容并删除

我们之前的del语句和pop()函数都是依靠列表的索引来删除索引下的元素，remove()则是不靠索引，而是根据元素的具体内容来删除。

>>> num = ['Hello','你好',666]
>>> num
['Hello', '你好', 666]
>>> num.remove(666)
>>> num
['Hello', '你好']
>>> num.remove('你好')
>>> num
['Hello']

列表分片

将一个列表只输出或显示或复制一部分数据元素，就是所谓的列表分片

>>> num = ['HUAWEI',"CHINA",'Mirror','XIAOMI']
>>> num
['HUAWEI', 'CHINA', 'Mirror', 'XIAOMI']
>>> num[0:1]
['HUAWEI']
>>> num[0:2]
['HUAWEI', 'CHINA']
>>> num[0:4]
['HUAWEI', 'CHINA', 'Mirror', 'XIAOMI']

>>> num[:2]
['HUAWEI', 'CHINA']
>>> num[:]
['HUAWEI', 'CHINA', 'Mirror', 'XIAOMI']
>>> num[2:]
['Mirror', 'XIAOMI']

仔细观察，发现分片的[x:y]是左闭右开的范围（原则）【python里很多时候和范围有关的闭合问题都是左闭右开的原则】

同时，分片机制还支持省略范围值；即左为空则从0开始，右为空则到最后一个元素结束，左右皆为空则全部元素输出；

分片的高级玩法

大家都认为分片只有两个参数？

分片有三个参数 ==> [x:y:z]

? x：开始

? y： 结束

? z： 步长（即每次递加的数量为z也可以理解为数学中的等差概念）

>>> num = [] // 创建一个空数组
>>> for i in range(1,10):
    num.append(i)
>>> num
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> num[0:10:2]
[1, 3, 5, 7, 9]

深浅复制初讨论

>>> list = [1,2,3,4]
>>> copy = list
>>> copy1 = list
>>> copy2 = list[:]
>>> copy1
[1, 2, 3, 4]
>>> copy2
[1, 2, 3, 4]

从上边可以看出，list直接复制和list[:]分片复制的结果一样，但其实暗藏心急哦！

>>> list.append(5)
>>> copy1
[1, 2, 3, 4, 5]
>>> copy2
[1, 2, 3, 4]

向原来的源列表 append() 添加一个元素，发现copy1的内容和list源列表一同别改变（append()操作）

  • 解释：

copy1 = list : 属于将list的内存地址给了copy1，

copy2 = list[:]：属于将list的值给了copy2

列表比较

列表支持比较运算符的比较操作：

>>> list1 = [123]
>>> list2 = [234]
>>> list3 = [123]
>>> list1 < list2
True
>>> list1 <= list3
True
>>> list1 == list3
True
>>> list1 != list2
True
>>> list1.append(234)
>>> list2.append(123)

>>> list1
[123, 234]
>>> list2
[234, 123]
>>> list1 > list2
False

两个列表的比较是根据ASCII值的大小比较的，如果遇到两个元素，则比较第一个，若第一个相同在比较第二个元素。

字符串列表

拼接和重复

>>> str1
['HUAWEI']
>>> str2
['CHINA']
>>> str1 + str2
['HUAWEI', 'CHINA']
>>> str1 * 3
['HUAWEI', 'HUAWEI', 'HUAWEI']
>>> str1 = str1 +str2
>>> str1
['HUAWEI', 'CHINA']
>>> str1[1] * 3
'CHINACHINACHINA'

元素判断：in/not in

  • 判断元素是否存在列表中：’str‘ in List / ’str‘ not in List
>>> str1
['HUAWEI', 'CHINA']
>>> "CHINA" in str1
True
>>> "CHINA" not in str1
False

元素查询

index()：查询元素的索引

>>> str = ["H","U","A","W","E","I"]
>>> str
['H', 'U', 'A', 'W', 'E', 'I']
>>> str.index("I")
5
>>> str.index("K")  // 元素不存在保存
Traceback (most recent call last):
  File "<pyshell#4>", line 1, in <module>
    str.index("K")
ValueError: 'K' is not in list
>>>

count()：查询元素重复次数

>>> list
[3, 4, 5, 2, 5, 66, 7, 2, 5, 7]
>>> list.count(5)
3

排序：reverse() 、sort()

  • reverse()：反向排列
  • sort()：升序排列
>>> list
[3, 4, 5, 2, 5, 66, 7, 2, 5, 7]
>>> list.reverse() // 反向排列
>>> list
[7, 5, 2, 7, 66, 5, 2, 5, 4, 3]
>>> list.sort()   // 升序
>>> list
[2, 2, 3, 4, 5, 5, 5, 7, 7, 66]
>>> list.reverse()  // 反向排列 （srot+reverse ==> 降序）
>>> list
[66, 7, 7, 5, 5, 5, 4, 3, 2, 2]

元组

元组可以理解为：一旦定义不可被更改的列表。

元组创建

>>> tuple = (1,2,3,4,5)
>>> number = [1,2,3,4,5]
>>> tuple
(1, 2, 3, 4, 5)
>>> number
[1, 2, 3, 4, 5]

tuple是元组，number是列表；

可以发现；两者的定义有所不同

元组是由圆括号组成的一组列表数据，列表是由方括号组成的一组数据

元组访问

元组的访问方法和列表是一样的，主要通过元组的索引来访问元组的元素，和列表一样可以通过分片（切片）的方式访问。

>>> tuple
(1, 2, 3, 4, 5)
>>> tuple[2]
3
>>> tuple[3]
4
>>> tuple[:]
(1, 2, 3, 4, 5)

type() 方法

  • 返回参数的类型
>>> tup = ()
>>> num = []
>>> type(tup)
<class 'tuple'>
>>> type(num)
<class 'list'>

很多时候，都会认为圆括号定义的列表数据就是元组，然而并不是！

>>> del tup
>>> tup
Traceback (most recent call last):
  File "<pyshell#14>", line 1, in <module>
    tup
NameError: name 'tup' is not defined
>>> tup = 1,2,3,4
>>> type(tup)
<class 'tuple'>

没错，没有圆括号的列表数据也是tuple元组。

定义元组的特点是：逗号

>>> (6)*6
36
>>> (6,)*6
(6, 6, 6, 6, 6, 6)

所以在元组的定义时候，需要一个逗号告诉程序，这是元组

>>> tup = (1,2,3,)
>>> type(tup)
<class 'tuple'>

这是最标准的定义方法，为什么？

元组更新与删除

  • 更新：

元组和列表的功能除了数据改变以外几乎一致，一个元组的数据是不可以改变的，但元组和元组之间是可以拼接的

>>> tup
(1, 2, 3)
>>> tup = tup[:3] + 4, + 5,
Traceback (most recent call last):
  File "<pyshell#28>", line 1, in <module>
    tup = tup[:3] + 4, + 5,
TypeError: can only concatenate tuple (not "int") to tuple
>>> tup = tup[:3] + (4,) + (5,6,)
>>> tup
(1, 2, 3, 4, 5, 6)

tup利用拼接将tup元组数据进行了更新；

注意：

? 这里在拼接的时候，将拼接的内容均用括号和逗号等标志表示这是一个元组数据，否则会被程序认为是一个字符或者数字数据。

逗号是元组的标志定义

  • 删除：
>>> tup = tup[:2] + tup[4:]
>>> tup
(1, 2, 5, 6)

通过拼接方法覆盖掉需要删除的元素，以此达到删除元素的目的。

  • 总结：

元组的数据是不变的，但是元组可以和列表一样自由的拼接：

? 利用末尾的切片拼接的方式让元素增加元素（注意元组元素逗号标识）

? 利用分片拼接的方式切除删除元素的前后内容拼接成一个新的元组

字符串

  • Python3的所有字符串都是Unicode（编码）字符串

创建

>>> char = "HUAWEI"
>>> str = 'XIAOMI'
>>> char
'HUAWEI'
>>> str
'XIAOMI'

字符串的创建可以使用单引号和双引号

字符串修改

>>> str = str[:3] + "-" + str[3:]
>>> str
'XIA-OMI'

字符串的修改和元组类似，采用分片拼接的方式实现更改字符串内容。

ps：是重新组成新的字符串给一个新的字符串变量所以要赋值

字符串格式化

format()

  • 按照索引坐标
>>> '{0}-{1}={2}'.format('XIAOMI','HUAWEI','CHINA')
'XIAOMI-HUAWEI=CHINA'

从代码中可以看出，字符串中的花括号内容是对应这format方法的参数值索引内容，通俗说：花括号里的索引会将format中的对应的参数值调用组成一个字符串。{format中的参数称为：位置参数}

  • 按照(关键字)键值对
>>> '{x}-{h}={c}'.format(x='XIAOMI',h='HUAWEI',c='CHINA')
'XIAOMI-HUAWEI=CHINA'
  • 注意：位置参数索引要放在关键字索引前面

格式化操作

格式化操作符

格式符号 描述
%c 格式化字符以及ASCII
%s 格式化字符串
%d 格式化整数（十进制）
%o 格式化无符号八进制
%x 、%X 格式化无符号十六进制（小写、大写）
%f 格式化浮点数
%e 、%E 格式化科学计数法浮点数

以上为常见的格式符号操作；和C语言异曲同工。

格式化操作书写

'[格式化操作符]' % [需要格式化操作的内容]
>>> '%c' % 99
'c'

格式化操作的表达方式是：百分号 ==> %

辅助参数

参数命令 描述
m.n m为最小从宽度，n为小数点后的位数
- 左对齐
+ 证书前显示加好
# 在八进制和十进制结果中分别显示：0o 和 0x/0X
0 数字前面用”0“填充空格
转义字符 描述
?‘ 单引号
?" 双引号
?a 系统响鸣
?b 退格符
?n 换行符
?t ， ?v 制表符（8个空格）
?f 换页符
?r 回车符
?\ 反斜杠
?0 代表一个空字符

序列

  • 列表、元组、字符串（*）都可以视为可迭代对象

list()：可迭代对象转为列表

>>> list = list((1,2,3,4))
>>> list
[1, 2, 3, 4]
>>> list = list("HUAWEI")
>>> list
['H', 'U', 'A', 'W', 'E', 'I']

tuple()：可迭代对象转为元组

>>> tuple = tuple("HUAWEI")
>>> tuple
('H', 'U', 'A', 'W', 'E', 'I')
>>> type(tuple)
<class 'tuple'>

str()：obj对象转为字符串

>>> s = str(1)
>>> s
'1'
>>> type(s)
<class 'str'>
>>> tuple(s)
('1',)

len(sub)：返回参数长度

>>> num = [1,2,3,5,6,7]
>>> len(num)
6

max()/min()：序列最大/最小值

>>> num = [1,2,3,5,6,7]
>>> len(num)
6
>>> max(num)
7
>>> min(num)
1

sum()：返回总和

>>> num = [1,2,3,5,6,7]
>>> sum(num)
24

sorted()：排序

>>> num
[12, 24, 33, 32, 243, 3, 6, 23, 15, 7, 6, 5, 3, 2, 1]
>>> sorted(num)
[1, 2, 3, 3, 5, 6, 6, 7, 12, 15, 23, 24, 32, 33, 243]
>>> num
[12, 24, 33, 32, 243, 3, 6, 23, 15, 7, 6, 5, 3, 2, 1]
>>> num.sort()
>>> num
[1, 2, 3, 3, 5, 6, 6, 7, 12, 15, 23, 24, 32, 33, 243]

代码中我们和前面的sort()进行了对比发现

? sorted()：返回升序后的结果但不改变原有数据

? sort()：将源列表进行了升序

reversed()：逆向迭代

>>> list = list((2,4,67,3,7,3,8))
>>> for i in reversed(list):
    print(i,end='-')

8-3-7-3-67-4-2-

可以看出，reversed()方法会将一个可迭代的序列逆向迭代输出

enumerate()：生成二元组

二元组：元素为2的元组构成一个迭代对象，每个二元组有迭代参数的索引和对应的元素组成。

>>> for i in enumerate(list):
    print(i)

(0, 'H')
(1, 'U')
(2, 'A')
(3, 'W')
(4, 'E')
(5, 'I')

zip()：迭代参数合为元组

返回可迭代参数共同组成的元组

>>> list
[2, 4, 67, 3, 7, 3, 8]
>>> str
['H', 'U', 'A', 'W', 'E', 'I']
>>> for i in zip(list,str):
    print(i)

(2, 'H')
(4, 'U')
(67, 'A')
(3, 'W')
(7, 'E')
(3, 'I')

函数

函数创建、调用

函数的含义就是将需要的且重复的功能代码封装在一个对象函数中，需要使用的时候直接调用即可。

def out():
    print("Hello,World!")
    print("I am Mirror")

out() // 调用out函数
Hello,World!
I am Mirror

函数参数

在函数定义的时候，可以在括号内添加参数设置，为函数设置参数，在调用函数时就会要求传入参数，函数体内也可以引用这个参数值进行工作。

def name(s):
    print(s)

def sum(x,y):
    print(x+y)

name("Mirror")
sum(1,2)
================ RESTART ================
Mirror
3

函数可以接收零个或多个参数值，在函数定义的时候，参数的数据类型可以不定义

函数返回值

def name(s):
    return "I am {0}".format(s)

def sum(x,y):
    return "SUM = {0}".format(x+y)

print (name("Mirror"))
print (sum(1,2))
================ RESTART================
I am Mirror
SUM = 3

灵活的函数

形参和实参

从上例函数的参数认识到了参数的设置和传递，但是如果我们不知道我们传递多少个数据参数的时候怎么办？

  • 形参：函数创建时的参数定义
  • 实参：函数调用过程中有调用出传递的参数

函数文档

  • 指在函数定义下方注明函数的具体作用，增加可读性

一般情况下，在嗲吗开头的三引号里不会打印出来，但是依旧会被存储，和注释的功能非常的类似，我们可以在调用的时候获取这个三引中的内容，了解函数的作用

_ _ doc _ _：获取函数
def sum(x,y):
    """ 返回 x,y 的求和"""
    return "SUM = {0}".format(x+y)

print (sum.__doc__)
================ RESTART ================
 返回 x,y 的求和

关键字函数

def sum(x,y):
    """ 返回 x,y 的求和"""
    return "SUM = {0}".format(x+y)

print (sum(x=1,y=2))

将形参的名称作为关键字，采用”赋值“模式对指定的形参传递实参

默认参数

def sum(x=1,y=2):
    """ 返回 x,y 的求和"""
    return "SUM = {0}".format(x+y)

print (sum())

默认参数：函数定义形参的同时给形参设置一个默认的参数，如果函数调用时为接收到实参传递则使用形参的默认参数进行运行

可变参数

回到形参时提出的关于不知道传递参数：

从上例函数的参数认识到了参数的设置和传递，但是如果我们不知道我们传递多少个数据参数的时候怎么办？

这时候就需要我们设置一个可变的形参（参数）：

* 形参名

def sum(* s):

    print(len(s))
    print(type(s))

sum(1,2,3,4,5,6,7)

================ RESTART ================
7
<class 'tuple'>

观察分析得出：使用星号表示的形参会自动将接收的实参序列压缩为一个”元组“，我们在没有使用可变参数的时候只可以传递单个（数字、字符、字符串）参数

  • 可变参数可以接收的是：可迭代的序列（列表，元组，字符，字符串……）

字典集合

  • python的字典集合采用：（Key：Value）键值对进行保存、读取等操作

字典创建（dict）

>>> dict = {1:10086,"a":"CHINA"}
>>> dict
{1: 10086, 'a': 'CHINA'}
>>> dict[1]  // 根据Key索引并返回Value
10086
>>> dict["a"]
'CHINA'

字典的标志特点就是：花括号包围的键值对序列

  • Key：是独一无二的，在同一个字典集合中不会重复
  • Value：每一个Value对应一个Key，Value可以重复，但必须不可变

字典内置操作

formkeys()：创建返回新字典

  • 参数：

    • key：必须
    • Value：默认None
>>> del dict
>>> dict.fromkeys((1,2,3))
{1: None, 2: None, 3: None}

返回字典内容

keys()：返回字典所有Key值
>>> dict
{1: None, 2: None, 3: None}
>>> dict.keys()
dict_keys([1, 2, 3])
values()：返回字典所有Value值
>>> dict.values()
dict_values([None, None, None])
items()：返回字典所有项
>>> dict.items()
dict_items([(1, None), (2, None), (3, None)])

get()：查询一个key的value

>>> dict
{1: 10086, 'a': 'CHINA'}
>>> dict.get("a")
'CHINA'
>>> dict.get(1)
10086
>>> dict.get("CHINA")
>>> dict.get(112)

get()查询一个key，如果不存在不会返回报错！可以利用 in/not in 来实现判断是否存在

claer()：清空字典

>>> dict.clear()
>>> dict
{}

ps： 是清空内容不是删除

copy()：复制字典

>>> dict
{1: 10086, 'a': 'CHINA'}
>>> c = {} // 定义一个空字典
>>> c
{}
>>> type(c)
<class 'dict'>
>>> c = dict.copy()
>>> c
{1: 10086, 'a': 'CHINA'}

pop()：弹出（删除）值

  • pop(key)：删除key和对应的value
  • popitem()：删除最后一个key和value
>>> dict = {1:10086,"a":"CHINA"}
>>> dict.pop(1)
10086
>>> dict
{'a': 'CHINA'}
>>> dict = {1:10086,"a":"CHINA"}
>>> dict.popitem()
('a', 'CHINA')
>>> dict
{1: 10086}

update()：更新字典

  • dict.update(dict)
>>> dict.update({2:2019})
>>> dict
{1: 10086, 'a': 'CHINA', 2: 2019}

集合创建（set）

  • 先看dict和set的区别
>>> dict1 = {}
>>> dict2 = {1,2,3,4,5} // 集合创建
>>> type(dict1)
<class 'dict'>
>>> type(dict2)
<class 'set'>

可以通过集合与字典的比较发现集合的特点：

? 集合是使用花括号但不适用键值对，以逗号分隔的序列

  • 集合开始
>>> set = {1,2,3,4,5,6}

访问集合

>>> set1
{1, 2, 3, 4, 5, 6}
>>> for i in set1:
    print(i,end=" ")

1 2 3 4 5 6

Python文件

文件打开 open()

操作符

标志 描述
r 以只读方式打开文件
w 以写入方式打开文件
x 文件存在会抛出异常
a 以写入方式打开，已存在文件可追加
b 以二进制打开文件
t 以文本方式打开
+ 可读写模式
U 通用换行符支持

open()函数

open()：用于创建一个文件对象，以便其他操作使用该文件对象

  • 单参数：可以是文件的具体路径和文件名（如果只是文件名会索引当前目录）
  • 操作符：决定文件的打开模式（默认为只读 ”r“）

操作函数

close()：关闭文件

read()：读取字符

  • read(size=-1)：从文件中读取size指定的字符内容大小；未赋值表示读取全部内容并作为String返回

readline()：读取一行字符串

write()：向文件输出内容

writelines()：向文件输出序列

seek()：移动文件指针

  • seek(offset,form)：从form偏移offset字节

    • offset：0 = 起始；1 = 当前位置；2 = 末尾

tell()：返回当前文件的位置

OS 文件模块

os模块；import os 导入os模块

目录操作

getcwd()：获取当前目录
chdir()：切换目录
listdir()：查看任意目录内容
mkdir()：创建文件夹（目录）
makedirs()：创建多级文件夹（目录）

删除操作

remove()：删除指定文件
radir()：删除指定文件夹（目录）
removedirs()：删除多级文件夹（目录）
rename()：文件/文件夹 重命名

系统操作

system()：调用工具
walk()：遍历子目录返回三元组

path 路径操作

path.basename()：获取文件名
path.dirname()：获取路径名
path.join()：完整路径join
path.split()：分隔路径和文件名
path.splitext()：分隔文件名和扩展名
path.getsize()：获取文件大小（字节）

path 时间函数

path.getatime()：最近访问时间
path.getctime()：创建时间
path.getmtime()：修改时间

prckle()模块

可以将对象以文件的形式存放在磁盘中；是一种简单的持久化功能

python的所有数据类型都可以使用 prckle()来序列化存放磁盘

异常处理

AssertionError：断言

assert在测试程序的时候，在代码植入检查点

>>> list = ['Mirror']
>>> assert len(list)>0
>>> list.pop()
'Mirror'
>>> assert len(list)>0
Traceback (most recent call last):
  File "<pyshell#3>", line 1, in <module>
    assert len(list)>0
AssertionError

assert断言：在其语句后面的条件成立的时候则不会编译assert，若断言条件满足后则会在程序中报错。

如上例代码程序：原先list列表内有一个元素，assert没有报错，但是pop方法弹出（删除）元素后，assert的条件得不到满足就会报错

try - except语句

try:
    检测范围
except exception[as e]:
    检测发现exception异常后的处理方法
finally:// 可选
    必须执行的代码块
  • 范例：
>>> try:
        file = open("a.txt")
        file.close()
    except OSError:
        print("Error")

Error

如范例中的程序，检测到在调用file文件对象的时候发生了OSError错误，由此执行报错（异常）代码执行块

>>> try:
        file = open("a.txt")
        file.close
    except OSError as e:
        print(str(e) + "Error")
    except TypeError as e:
        print(str(e) + "Error")

[Errno 2] No such file or directory: 'a.txt'Error

如上；利用as error方法，将错误信息写入e变量中，在以str的类型输出错误信息；同时发现，可以定义多种不同的错误类型和报错输出。

异常

Exception： 所有异常的基类（可以接收任何类的异常）

AssertionError：assert语句失败（assert条件不成立）

AttributeError：访问一个对象没有的属性（对象属性不存在）

IOError：输入输出操作异常

ImportError：无法引入模块或包（路径错误等）

IndexError：索引超出序列边界

KeyError：访问字典中不存在的key

KeyboardInterrupt：Ctrl+C被触发

NamError：使用的对象无变量

SyntaxError：代码逻辑语法错误

TypeError：对象类型和语句要求不符

UnboundLocalError：全局变量的异常

ValueError：传入的value值异常出错

ZeroDivisonError：触发除零的异常

第三方GUI模块：EasyGUI

类和对象

认识类和对象

类：class 类名称:

对象：def 方法名():

一个程序可以由多个类组成，一个类由多个对象方法组成；

self关键字：代表自己的对象参数

类的方法与普通的函数只有一个区别：它们必须有一个额外的参数名称，但在调用这个方法的时候不可以为这个参数赋值，python会提供这个值。这个特别的变量指的是对象的本身，名为：self；

初探Python魔法方法

__ init__()构造方法

只要实例化一个对象前，这个方法就会在对象被创建前自动调用；参数形参也会自动传入该方法中；可以利用重写该方法实现初始化的操作

class Potate:
    def __init__(self.name):
        self.name = name
    def kick(self):
        pirnt(self.name)

公有和私有

public ：公有、公共

private：私有

以上是C++和Java方法；

在Python中表示私有的属性：变量名前两个下划线“__”

继承

class 类名(被继承的类):
  • self：只可以使用自己的类中的对象
  • super：可以从子类中调用父类中的属性对象

Python支持多重继承，即一个类继承多个父类；【不建议使用】

原文地址：https://www.cnblogs.com/wangyuyang1016/p/11260913.html

时间： 2024-09-30 21:33:49

Python复习 一的相关文章

Python 复习（二）

2019-02-18 16:12:57 时隔半个多月,又将Python复习提上了议程.... 迭代器与生成器   之前的学习过程中没有理解清楚迭代器的含义及原理,特别是 yield 的用法.今天算是弄明白了. 迭代器就是生成迭代序列.用 __iter__()类初始化,__next__()类遍历. Ls = [1,2,3] it = iter(Ls) while True: try: print(next(it)) except StopIteration: sys.exit() 用了yield的

Python复习——复习4次课（12月1日）

任务: 复习4次课(12月1日)1.1 函数定义1.2 函数的参数1.3 函数的默认参数1.4 函数的变量1.5 函数的返回值1.6 多类型传值和冗余参数1.7 函数的递归调用 笔记: 函数定义 函数就是完成特定功能的一个语句组,这组语句可以作为一个单位使用,并且给它取一个名字.可以通过函数名在程序的不同地方多次执行(这通常叫函数调用).预定义函数 可以直接使用自定义函数 用户自己编写 为什么使用函数降低编程难度 - 通常将一个复杂的大问题分解成一系列的小问题,然后将小问题划分成更小的问题,当问

Python复习——复习6次课（12月3日）

复习6次课(12月3日)2.5/2.6 模块使用2.7 面向对象介绍2.8 类的属性2.9 类的方法3.0 类的内置方法3.1/3.2 类的继承 笔记: 模块: 模块是Python组织代码的基本方式.一个Python脚本可以单独运行,也可以导入到另一个脚本中运行,当脚本被导入运行时,我们将其称为模块(module).所有的.py文件都可以作为一个模块导入模块名与脚本的文件名相同例如我们编写了一个名为hello.py的脚本,则可以在另一个脚本中用import hello语句来导入它. 包:Pyth

Python 复习（五） 标准库复习

2019-02-21 19:45:47 话不多说,开始! Python 二级要求掌握的库有:turtle.random.time.其他库有request.jieba等,都比较简单,现在开始复习. (一) turtle库 画图.导入方式 import turtle as t 1.1 窗体函数 t.setup(width,lenth,startx,starty).turtle默认起始点是中心点,以前右为正. 1.2 画笔状态 画笔状态函数 pensize()/width() 设置画笔宽度 penup

Python 复习

Python简介 Python是著名的“龟叔”Guido van Rossum在1989年圣诞节期间,为了打发无聊的圣诞节而编写的一个编程语言. 现在,全世界差不多有600多种编程语言,但流行的编程语言也就那么20来种.如果你听说过TIOBE排行榜,你就能知道编程语言的大致流行程度.这是最近10年最常用的10种编程语言的变化图: 总的来说,这几种编程语言各有千秋.C语言是可以用来编写操作系统的贴近硬件的语言,所以,C语言适合开发那些追求运行速度.充分发挥硬件性能的程序.而Python是用来编写应

python复习提纲

一.python 语法与工具 1.关键字 2.数据类型 3.内存管理机制 4.构造函数与析构函数 二.python框架 1.GUI框架 2.Web框架 3.爬虫框架 4.绘图框架 5.设计模式 三.python类库 1.数据库连接类 2.SOAP操作类 3.cgi模块 四.编程实践 1.生成器编程 2.soket编程

python复习

一.数据类型 1.整数 例如:1,100,-1,-100 或者使用十六进制表示 0xff00,0xa5b4c3d2...: 2.浮点数 带有小数点的统称为小数: 3.字符串 用‘’或“”括起来的任意文本,如‘abc’,“def”,表示方法不同结果相同: 4.布尔值 布尔值只有两种False.Ture: 通过and.or .not运算获得布尔值: 其中 0,空字符串''和None看成False,其他数值和非空字符串都看成Ture: 例子: a = True print a and 'a=T' or

python 复习 4-1 函数、参数、返回值、递归

函数 完成特定功能的一个语句组,这个语句组可以作为一个单位使用,并且给它组语句取一个名子,即函数名 可以通过函数名在程序不同地方多次执行,即函数调用 预定义函数(可以直接使用) 自定义函数(自编写的) 函数的定义: def 函数句([参数列表]): //定义 ``` def hello (): print(hello world) #### 函数的调用: - 函数名([参数列表]) //调用 hello() #### 函数的参数: 形式参数和实际参数 - 在定义函数时,函数名后面的括号中的变量名

python复习1

比如常用的数学常数π就是一个常量.在Python中,通常用全部大写的变量名表示常量: Python支持多种数据类型,在计算机内部,可以把任何数据都看成一个"对象",而变量就是在程序中用来指向这些数据对象的,对变量赋值就是把数据和变量给关联起来. 对变量赋值x = y是把变量x指向真正的对象,该对象是变量y所指向的.随后对变量y的赋值不影响变量x的指向. Python的整数没有大小限制,而某些语言的整数根据其存储长度是有大小限制的,例如Java对32位整数的范围限制在-214748364