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支持多重继承,即一个类继承多个父类;【不建议使用】
Python复习 一的更多相关文章
- 用Python复习离散数学(一)
最近要复习离散数学,不想挂啊,但是又想编程,大家知道啦,程序员离不开代码啊,所用想边复习边写代码,所以就自己用代码去实现一下离散的知识点,当做复习,自知自己的Python很渣,也想借此巩固一下基础,哈 ...
- 九九乘法表的python复习
九九开始的复习 这周复习之前的学的知识关于range函数,gormat函数,print的使用总结一下 从一个小例子开始,开始我的回顾吧, 大家都是从那个九九乘法表开始的数学之旅,从一一得一,开始了我们 ...
- Python 复习-1
#!/usr/bin/env python # -*- coding:utf-8 -*- # @Time : 2017/10/27 22:46 # @Author : lijunjiang # @Fi ...
- 后端程序员之路 20、python复习
Welcome to Python.orghttps://www.python.org/ 怎么用最短时间高效而踏实地学习 Python? - 知乎https://www.zhihu.com/quest ...
- python复习
1.input和raw_input的区别 input假设输入的都是合法的python表达式,如输入字符串时候,要加上引号,而raw_input都会将所有的输入作为原始数据 2.原始字符串前面加上r,e ...
- Python复习笔记-字典和文件操作
抽时间回顾2年前自己做过的python工具,突然感觉不像自己写的,看来好久没用过python的字典和文件操作了,查询资料和网页,整理如下: 一.字典 键值对的集合(map) 字典是以大括号“{}”包围 ...
- 用Python复习离散数学(二)
这次复习的是计数问题,立刻走起吧! 1.乘法原理 如果一项工作需要t步完成的,第一步有n1种不同的选择,第二步有n2种不同的选择,……,第t步有nt中不同的选择,那么完成这项工作所有可能的选择种数为: ...
- python复习。知识点小记
1.对于单个字符的编码,Python提供了ord()函数获取字符的整数表示,chr()函数把编码转换为对应的字符: >>> ord('A') >>> ord('中' ...
- python复习1
比如常用的数学常数π就是一个常量.在Python中,通常用全部大写的变量名表示常量: Python支持多种数据类型,在计算机内部,可以把任何数据都看成一个“对象”,而变量就是在程序中用来指向这些数据对 ...
随机推荐
- Redis集群与分布式介绍以及搭建Redis-Cluster
1 Redis集群 1.1 什么是集群 集群就是很多服务器组成的一个网络.指的是将多台服务器集中在一起,实现同一业务. 1.2 为什么要集群 一台服务器不能满足开发需要的时候,需要多台服务器来支持.这 ...
- Linux MySQL的root无法登录数据库ERROR 1045 (28000)
Linux环境下,脚本自动安装完数据库,命令行用mysql -uroot -ppasswaord 登录却报了这么个错: ERROR 1045 (28000): Access denied for us ...
- 二维码生成插件qrious
1.qrious是基于canvas的纯JS二维码生成插件 1.1什么是二维码 二维码又称QR Code,QR全称Quick Response,是一个近几年来移动设备上超流行的一种编码方式,它比传统的B ...
- CSDN屏蔽广告
CSDN俨然是一家广告网站了,各种广告层出不穷,且毫无底线.经常性的展示一些植发.防脱的广告,实在影响心情.另外,在复制内容的时候,会通过js给你带上一段来源,对于版权保护这是好事儿,但是对于直接复制 ...
- REST架构指导方案
目录 REST架构指导方案 何为REST 在WEB系统中应用REST风格 应用约束 对资源应用正确的动词语义 名词性的URI地址 RESTFUL的URL路径实践 单一资源的路径制定 复杂查询的路径制定 ...
- SpingSecurity + SpringSession 死磕
SpingSecurity + SpringSession 整合 疯狂创客圈 Java 高并发[ 亿级流量聊天室实战]实战系列 [博客园总入口 ] 架构师成长+面试必备之 高并发基础书籍 [Netty ...
- Redux学习及应用
Redux学习及应用 一:Redux的来源? Redux 是 JavaScript 状态容器,提供可预测化的状态管理.Redux是由 Flux 演变而来,但受 Elm 的启发,避开了 Flux 的复杂 ...
- WPF数据可视化-趋势图
环境: 系统: Window 7以上: 工具:VS2013及以上. 研发语言及工程: C# WPF 应用程序 效果: 简介: 不需要调用第三方Dll, 仅仅在WPF中使用贝塞尔曲线,不到500 ...
- Python中Pyyaml模块的使用
一.YAML是什么 YAML是专门用来写配置文件的语言,远比JSON格式方便. YAML语言的设计目标,就是方便人类读写. YAML是一种比XML和JSON更轻的文件格式,也更简单更强大,它可以通过缩 ...
- How to: Initialize Business Objects with Default Property Values in XPO 如何:在 XPO 中用默认属性值初始化业务对象
When designing business classes, a common task is to ensure that a newly created business object is ...