python编程基础

python
字数统计: 9.6k   |   阅读时长≈ 37 分钟

基础

如何写 Python 程序

  1. 打开你喜欢的编辑器。
  2. 键入例子中给出的程序代码。
  3. 用注释中给的文件名来保存文件，我保持将所有 Python 程序保存成扩展名为.py 的习惯。
  4. 用带命令行解释器运行.py 程序，或者用 IDLE 运行程序。也可以用前面提到的执行方式。

注释

通过用自己熟悉的语言，在程序中对某些代码进行标注说明，这就是注释的作用，能够大大增强程序的可读性

单行注释以#开头或'包裹，多行注释用'''或"""包裹，即单独的字符串被视为注释

注释的内容不当做程序运行，起辅助说明作用

1
2
3
4
5
6
7
8
#这是一个注释
'这是一个注释'
'''
这是一个多行注释
'''
"""
这也是一个多行注释
"""

编码注释：在程序的开头写入如下代码，即告知程序以utf-8编码(中文)执行，这是python语法规范推荐的方式

1
# -*- coding:utf-8 -*-

标识符与关键字

  • 标识符

标识符的第一个字符必须是字母表中的字母（大写或小写）或者一个下划线_,其他部分可以由字母（大写或小写）、下划线或数字（0-9）组成。

标识符名称是对大小写敏感的。例如， myname 和 myName 不是一个标识符。

  • 关键字

关键字是python已经使用的了的标识符，不允许开发者自己定义和关键字相同的名字的标示符。

逻辑行和物理行

物理行是你在编写程序时所看见的。逻辑行是 Python 看见的单个语句。 Python 假定每个物理行对应一个逻辑行。如果你想要在一个物理行中使用多于一个逻辑行，那么你需要使用分号（;）来特别地标明这种用法。分号表示一个逻辑行/语句的结束。

1
2
3
4
5
6
7
8
9
10
i = 5
print(i)		#两个物理行，两个逻辑行

i = 5;
print(i);		#两个物理行，两个逻辑行

i = 5;print(i);	#一个物理行，两个逻辑行

print('hel\
lo')			#两个物理行，一个逻辑行

缩进

在 Python 中空白非常重要。实际上，在每行开头的空白很重要。称之为缩进。在行首的主要的空白（空格键和制表符）用来决定逻辑行缩进的层次，从而来决定语句分组。同一层次的语句必须有相同的缩进。每一组这样的语句称为一个块。错误的缩进会引发错误。

不要混合使用制表符和空格来缩进，因为这在跨越不同的平台的时候，无法正常工作。我强烈建
议你在每个缩进层次使用单个制表符或两个或四个空格。选择这三种缩进风格之一。更加重要的
是，选择一种风格，然后一贯地使用它，即只使用这一种风格。

变量

变量就是我们想要的东西——它们的值可以变化，即你可以使用变量存储任何东西。变量只是你的计算机中存储信息的一部分内存。

变量使用标识符命名，使用变量时只需要给它们赋一个值。不需要声明或定义数据类型。

动态变量名:exec('var{} = {}'.format(i, i))

locals() 函数会以字典类型返回当前位置的全部局部变量。

exec语句用来执行储存在字符串或文件中的Python语句

示例代码：

1
2
3
4
x = 12	
y = 2+x
print(x)
print(y)
1
2
12
14

变量可以有不同类型的值，称之为数据类型。基本数据类型是数字和字符串。

输出

链接：格式化输出详解

1
2
3
4
5
6
7
8
9
10
11
12
#普通输出
a = 'hello world'
print('hello world')
print(a)
#格式化输出
print("python says:%s"%a)
print("python says:{0}".format(a))
#字符串格式化
print("python says:%10s"%a)		#右对齐，占位符10位
print("python says:%-10s"%a)	#左对齐，占位符10位
print("python says:%.2s"%a)		#截取2位字符串
print("python says:%10.2s"%a)	#10位占位符，截取两位字符串
格式符号 转换
%c 字符
%s 通过str() 字符串转换来格式化
%i 有符号十进制整数
%d 有符号十进制整数
%u 无符号十进制整数
%o 八进制整数
%x 十六进制整数（小写字母）
%X 十六进制整数（大写字母）
%e 科学计数法（小写’e’）
%E 科学计数法（大写“E”）
%f 浮点实数
%g ％f和％e 的简写
%G ％f和％E的简写

输入

1
a = input("请输入:")

  1. 小括号中放入的是提示信息，用来在获取数据之前给用户的一个简单提示

  2. 在从键盘获取了数据以后，会存放到等号右边的变量中

  3. 会把用户输入的任何值都作为字符串来对待

操作符和表达式

操作符

算术运算符

以下假设变量a为10，变量b为21：

运算符 描述 实例
+ 加 - 两个对象相加 a + b 输出结果 31
- 减 - 得到负数或是一个数减去另一个数 a - b 输出结果 -11
* 乘 - 两个数相乘或是返回一个被重复若干次的字符串 a * b 输出结果 210
/ 除 - x 除以 y b / a 输出结果 2.1
% 取模 - 返回除法的余数 b % a 输出结果 1
** 幂 - 返回x的y次幂 a**b 为10的21次方
// 取整除 - 向下取接近除数的整数 a//b 为 0

比较运算符

以下假设变量a为10，变量b为20：

运算符 描述 实例
== 等于 - 比较对象是否相等 (a == b) 返回 False。
!= 不等于 - 比较两个对象是否不相等 (a != b) 返回 True。
> 大于 - 返回x是否大于y (a > b) 返回 False。
< 小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。 (a < b) 返回 True。
>= 大于等于 - 返回x是否大于等于y。 (a >= b) 返回 False。
<= 小于等于 - 返回x是否小于等于y。 (a <= b) 返回 True。

赋值运算符

以下假设变量a为10，变量b为20：

运算符 描述 实例
= 简单的赋值运算符 c = a + b 将 a + b 的运算结果赋值为 c
+= 加法赋值运算符 c += a 等效于 c = c + a
-= 减法赋值运算符 c -= a 等效于 c = c - a
*= 乘法赋值运算符 c *= a 等效于 c = c * a
/= 除法赋值运算符 c /= a 等效于 c = c / a
%= 取模赋值运算符 c %= a 等效于 c = c % a
**= 幂赋值运算符 c **= a 等效于 c = c ** a
//= 取整除赋值运算符 c //= a 等效于 c = c // a

位运算符

运算符 描述 实例
& 按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0 (a & b) 输出结果 12 ，二进制解释： 0000 1100
| 按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。 (a | b) 输出结果 61 ，二进制解释： 0011 1101
^ 按位异或运算符：当两对应的二进位相异时，结果为1 (a ^ b) 输出结果 49 ，二进制解释： 0011 0001
~ 按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。~x类似于 -x-1 (~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。
<< 左移动运算符：运算数的各二进位全部左移若干位，由”<<”右边的数指定移动的位数，高位丢弃，低位补0。 a << 2 输出结果 240 ，二进制解释： 1111 0000
>> 右移动运算符：把”>>”左边的运算数的各二进位全部右移若干位，”>>”右边的数指定移动的位数 a >> 2 输出结果 15 ，二进制解释： 0000 1111

逻辑运算符

Python语言支持逻辑运算符，以下假设变量 a 为 10, b为 20:

运算符 逻辑表达式 描述 实例
and x and y 布尔”与” - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。 (a and b) 返回 20。
or x or y 布尔”或” - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。 (a or b) 返回 10。
not not x 布尔”非” - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。 not(a and b) 返回 False

成员运算符

除了以上的一些运算符之外，Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。

运算符 描述 实例
in 如果在指定的序列中找到值返回 True，否则返回 False。 x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in 如果在指定的序列中没有找到值返回 True，否则返回 False。 x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。

身份运算符

身份运算符用于比较两个对象的存储单元

运算符 描述 实例
is is 是判断两个标识符是不是引用自一个对象 x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False
is not is not 是判断两个标识符是不是引用自不同对象 x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。

运算符优先级

以下表格列出了从最高到最低优先级的所有运算符：

运算符 描述
** 指数 (最高优先级)
~ + - 按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
* / % // 乘，除，取模和取整除
+ - 加法减法
>> << 右移，左移运算符
& 位 ‘AND’
^ | 位运算符
<= < > >= 比较运算符
<> == != 等于运算符
= %= /= //= -= += = *= 赋值运算符
is is not 身份运算符
in not in 成员运算符
and or not 逻辑运算符

括号可改变优先级与结合顺序

数据类型

数

在 Python 中数的类型有三种：

  • 整数(int)：1，2，3
  • 浮点数(float)：1.0 1.1 52.3E-4 (表示 52.3乘以10的-4次方) 1e4(表示1乘以10的4次方)
  • 复数(comlex)：-5+4j 2.3-4.6j

在 Python 中不用区分‘long int’类型。默认的整数类型可以任意长(长度应该与内存包括虚拟内存的大小有关)。

示例代码：

1
2
3
4
5
6
print(type(1))		#print()为输出函数 type()获取参数的数据类型
print(type(-1))
print(type(1E4))
print(type(1.0))
print(type(52.3E-4))
print(type(-5+4j))

输出结果：

1
2
3
4
5
6
<class 'int'>
<class 'int'>
<class 'float'>
<class 'float'>
<class 'float'>
<class 'complex'>

字符串

字符串是字符的序列。字符串基本上就是一组单词。单词可以是英语或其它由 Unicode 标准支持的语言，其实这也意味着世界上几乎所有的语言,默认所有的字符串的编码是 Unicode 。一个字符串一旦创建，就不能再改变它。

字符串的使用

你可以用单引号指定字符串，如 'Quote me on this' 。所有的空白，即空格和制表符都照原样保留。在双引号中的字符串与单引号中的字符串的使用完全相同，例如 "What’s yourname?" 。分单双引号的作用主要体现引号中还有引号的情况如："Quote 'me' on this"

利用三引号（”””or’’’），你可以指示一个多行的字符串。你可以在三引号中自由的使用单引号和双引号。

示例代码：

1
2
3
4
5
6
7
8
9
10
print('Quote me on this')
print('''
This is a multi-line string. This is the first line.
2 This is the second line.
''')
print("What’s yourname?")
print("""
This is a multi-line string. This is the first line.
2 This is the second line.
""")

运行结果：

1
2
3
4
5
6
7
8
9
Quote me on this

This is a multi-line string. This is the first line.
2 This is the second line.

What’s yourname?

This is a multi-line string. This is the first line.
2 This is the second line.

字符串拼接

  • 格式化输出

  • ‘+’连接

1
2
3
4
age = 25
name = 'Swaroop'
print(name+'is'+str(age)+'years old')	#age 需转化为string类型
print('Why is '+name+'playing with that python?')
  • format 方法

有时我们并不想用其他信息来构造字符串。这儿 format() 方法就很有用。

示例代码：

1
2
3
4
age = 25
name = 'Swaroop'
print('{0} is {1} years old'.format(name, age))
print('Why is {0} playing with that python?'.format(name))

输出结果：

1
2
Swaroop is 25 years old
Why is Swaroop playing with that python?
  • print()连接
1
2
x = 2
print('他',x,'岁了')
1
他 2 岁了

字符串的操作

如有字符串mystr = 'hello world itcast and itcastcpp'，以下是常见的操作

find()

检测 str 是否包含在 mystr中，如果是返回开始的索引值，否则返回-1

1
mystr.find(str, start=0, end=len(mystr))

index

跟find()方法一样，只不过如果str不在 mystr中会报一个异常.

1
mystr.index(str, start=0, end=len(mystr))

count

返回 str在start和end之间 在 mystr里面出现的次数

1
mystr.count(str, start=0, end=len(mystr))

replace

把 mystr 中的 str1 替换成 str2,如果 count 指定，则替换不超过 count 次.

1
mystr.replace(str1, str2,  mystr.count(str1))

split

以 str 为分隔符切片 mystr，如果 maxsplit有指定值，则仅分隔 maxsplit 个子字符串

1
mystr.split(str=" ", 2)

capitalize

把字符串的第一个字符大写

1
mystr.capitalize()

title

把字符串的每个单词首字母大写

1
mystr.title()

startswith

检查字符串是否是以 obj 开头, 是则返回 True，否则返回 False

1
mystr.startswith(obj)

endswith

检查字符串是否以obj结束，如果是返回True,否则返回 False.

1
mystr.endswith(obj)

lower

转换 mystr 中所有大写字符为小写

1
mystr.lower()

upper

转换 mystr 中的小写字母为大写

1
mystr.upper()

ljust

返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串

1
mystr.ljust(width)

rjust

返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串

1
mystr.rjust(width)

center

返回一个原字符串居中,并使用空格填充至长度 width 的新字符串

1
mystr.center(width)

lstrip

删除 mystr 左边的空白字符

1
mystr.lstrip()

rstrip

删除 mystr 字符串末尾的空白字符

1
mystr.rstrip()

strip

删除mystr字符串两端的空白字符

1
mystr.strip()

rfind

类似于 find()函数，不过是从右边开始查找.

1
mystr.rfind(str, start=0,end=len(mystr) )

rindex

类似于 index()，不过是从右边开始.

1
mystr.rindex( str, start=0,end=len(mystr))

partition

把mystr以str分割成三部分,str前，str和str后

1
mystr.partition(str)

rpartition

类似于 partition()函数,不过是从右边开始.

1
mystr.rpartition(str)

splitlines

按照行分隔，返回一个包含各行作为元素的列表

1
mystr.splitlines()

isalpha

如果 mystr 所有字符都是字母 则返回 True,否则返回 False

1
mystr.isalpha()

isdigit

如果 mystr 只包含数字则返回 True 否则返回 False.

1
mystr.isdigit()

isalnum

如果 mystr 所有字符都是字母或数字则返回 True,否则返回 False

1
mystr.isalnum()

isspace

如果 mystr 中只包含空格，则返回 True，否则返回 False.

1
mystr.isspace()

join

mystr 中每个字符后面插入str,构造出一个新的字符串

1
mystr.join(str)

转义序列

因为一些符号在python语法中有特殊含义，如' " \ 等，不能直接在字符串使用,需要使用转义序列将其转义。

若你想指定一些字符串不被特殊处理，例如像转义序列，则需要通过在字符串前面加r或R来指定自然字符串。

转义字符 描述
\(在行尾时) 续行符
\\ \
\‘ ‘
\" “
\a 响铃
\b 退格(Backspace)
\e 转义
\000 空
\n 换行
\v 纵向制表符
\t 横向制表符
\r 回车
\f 换页
\oyy 八进制数，yy代表的字符，例如：\o12代表换行
\xyy 十六进制数，yy代表的字符，例如：\x0a代表换行
\other 其它的字符以普通格式输出

示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#常用的转义示例
print('='*20)
print('what\'s your name?')	#单引号
print('='*20)
print("what a \"good\" boy!")	#双引号
print('='*20)
print("换行：\n第一行\n第二行")	#换行
print('='*20)
print('制表符\t1\t2\t3')	#制表符(即键盘上的Tab键)
print('='*20)
print('1\\2\\3\\4\\5')	#反斜杠
print('='*20)
print('续行符：123\
456\
789')
print('='*20)
#自然字符串
print(r'换行：\n第一行\n第二行')	#可见\n失效了，其他可自己试一下，在字符串前加r或R即可

输出结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
====================
what's your name?
====================
what a "good" boy!
====================
换行：
第一行
第二行
====================
制表符     1       2       3
====================
1\2\3\4\5
====================
续行符：123456789
====================
换行：\n第一行\n第二行

列表

list 是处理一组有序项目的数据结构，即你可以在一个列表中存储一个序列的项目。

列表中的项目应该包括在方括号中，这样 Python 就知道你是在指明一个列表。一旦你创建了一个列表，你可以添加、删除或是搜索列表中的项目。由于你可以增加或删除项目，我们说列表是可变的数据类型，即这种类型是可以被改变的。

添加

假设有列表：a=[1,2];b=[3,4]

  • append：向列表添加元素
1
2
a.append(1,2)	#[1,2,3,4]
a.append(b)		#[1,2,[3,4]]
  • extend：向另一个集合中的元素逐一添加到列表
1
a.extend(b)		#[1,2,3,4]
  • insert(index,object)：在指定位置index前插入元素object
1
a.insert(1,3)	#[1,3,2]

修改

直接指定下标修改

查找

  • 使用in和not in

  • index

    检测 x 是否包含在 mylist 的指定区间中，如果是返回开始的索引值，否则返回一个异常

    1
    mylist.index(x, start=0, end=len(mystr))	#左闭右开

  • count()：返回 str在start和end之间 在 mystr里面出现的次数

1
mystr.count(str, start=0, end=len(mystr))

删除

  • del：根据下标进行删除
1
del mylist[2]
  • pop：删除最后一个元素
1
mylist.pop()
  • remove：根据元素的值进行删除
1
mylist.remove('123')

排序

  • sort方法是将list按特定顺序重新排列，默认为由小到大，参数reverse=True可改由大到小。

  • reverse方法是将list逆置。

列表嵌套

元组

元组用来将多样的对象集合到一起。元组和列表十分类似，只不过元组和字符串一样是不可变的即你不能修改元组。元组通过圆括号中用逗号分割的项目定义。

一个空的元组由一对空的圆括号组成，如 myempty = ()。然而，含有单个元素的元组就不那么简单了。你必须在第一个（唯一一个）项目后跟一个逗号，这样 Python 才能区分元组和表达式中一个带圆括号的对象。

index和count与字符串和列表中的用法相同

字典

字典类似于你通过联系人名字查找地址和联系人详细情况的地址簿，即，我们把键（名字）和值（详细情况）联系在一起。注意，键必须是唯一的，就像如果有两个人恰巧同名的话，你无法找到正确的信息。

你只能使用不可变的对象（比如字符串）来作为字典的键，但是你可以把不可变或可变的对象作为字典的值。

键值对在字典中以这样的方式标记：d = {key1 : value1, key2 : value2 }。注意它们的键/值对用冒号分割，而各个对用逗号分割，所有这些都包括在花括号中。

记住字典中的键/值对是没有顺序的。如果你想要一个特定的顺序，那么你应该在使用前自己对它们排序。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#创建字典
ab = { 'Swaroop' : 'swaroop@swaroopch.com',
'Larry' : 'larry@wall.org',
'Matsumoto' : 'matz@ruby-lang.org',
'Spammer' : 'spammer@hotmail.com'
}
#访问字典值
print("Swaroop's address is", ab['Swaroop'])
#删除字典值
del ab['Spammer']
print('\nThere are {0} contacts in the address-book\n'.format(len(ab)))
#遍历字典
for name, address in ab.items():
    print('Contact {0} at {1}'.format(name, address))
#添加/修改字典值
ab['Guido'] = 'guido@python.org'
if 'Guido' in ab:
    print("\nGuido's address is", ab['Guido'])
#清空整个字典
ab.clear()
1
2
3
4
5
6
7
8
9
10
11
#len()	测量字典中，键值对的个数
dict = {"name":'zhangsan','sex':'m'}
print(len(dict))
#keys()	返回一个包含字典所有KEY的列表
print(dict.keys())
#values()	返回一个包含字典所有value的列表
print(dict.values())
#items()	返回一个包含所有（键，值）元祖的列表
print(dict.items())
#has_key(key)	如果key在字典中，返回True，否则返回False	
print(dict.has_key('name'))

下标和切片

列表、元组和字符串都是序列，序列的主要特点是成员检验(inornot in)和索引操作符。

  • 切片的语法：[起始:结束:步长]
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
#例：
shoplist = ['apple', 'mango', 'carrot', 'banana']
name = 'swaroop'
#[开始:结束:步长]，包含开头不包含结尾，三个参数可选，默认步长为1，开头为0，结尾为-1，步长加符号表示逆序
print(shoplist[0])      #第一个
print(shoplist[1])      #第二个
print(shoplist[2])
print(shoplist[3])
print(shoplist[-1])     #倒数第一个
print(shoplist[-2])     #倒数第二个
print(name[0])          #第一个字母
print()
print(shoplist[1:3])    #第二个到第三个
print(shoplist[2:])     #第三个到最后一个
print(shoplist[1:-1])   #第二个到倒数第一个
print(shoplist[:])      #所有
print()
print(name[1:3])        #同shoplist，只是对象换成字符串
print(name[2:])
print(name[1:-1])
print(name[:])
print()
print(name[::2])		
print(name[1:5:2])		
print(name[::-2])		
print(name[4::-2])

集合

集合是没有顺序的简单对象的聚集。当在聚集中一个对象的存在比其顺序或者出现的次数重要时使用集合。

使用集合，可以检查是否是成员，是否是另一个集合的子集，得到两个集合的交集等等。

1
2
3
4
5
6
7
8
9
bri = set(['brazil', 'russia', 'india'])        #创建集合
print(bri)                                      #输出集合
print('india' in bri)                           #判断元素是否在集合中
print('usa' in bri)
bric = bri.copy()                               #复制集合
bric.add('china')                               #添加元素
print(bric.issuperset(bri))                     #判断bri是否为bric的子集
bri.remove('russia')                            #删除元素
print(bri.intersection(bric))                   #输出交集

引用

当你创建一个对象并给它赋一个变量的时候，这个变量仅仅引用那个对象，而不是表示这个对象本身！即两个变量名指向的是同一个内存，如果你只是想要使用另一个变量名，两个名称都引用同一个对象，那么如果你不小心的话，可能会引来各种麻烦。

数据类型转换

函数 说明
int(x [,base ]) 将x转换为一个整数
long(x [,base ]) 将x转换为一个长整数
float(x ) 将x转换到一个浮点数
complex(real [,imag ]) 创建一个复数
str(x ) 将对象 x 转换为字符串
repr(x ) 将对象 x 转换为表达式字符串
eval(str ) 用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s ) 将序列 s 转换为一个元组
list(s ) 将序列 s 转换为一个列表
chr(x ) 将一个整数转换为一个字符
unichr(x ) 将一个整数转换为Unicode字符
ord(x ) 将一个字符转换为它的整数值
hex(x ) 将一个整数转换为一个十六进制字符串
oct(x ) 将一个整数转换为一个八进制字符串

函数

定义与调用

1
2
3
4
5
6
7
#定义
def printInfo():
    '打印123'		#函数的文档说明
    print('123')
#调用
printInfo()
help(test)	#打印文档说明

函数的参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#定义
def printInfo(a):	#a为参数
    '打印123'
    print(a)
#调用
printInfo('123')	#传入参数的值
#缺省参数
def printinfo2(name,age=35):#缺省参数使用等号给予默认值，带有默认值的参数要位于参数列表最后
   # 打印任何传入的字符串
   print("Name: ",name)
   print("Age ", age)
#不定长参数
#有时可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，声明时不会命名。
def fun(a, b, *args, **kwargs):
    #加了星号（*）的变量args会存放所有未命名的变量参数，args为元组；而加**的变量kwargs会存放命名参数，即形如key=value的参数， kwargs为字典。
    print("a =", a)
	print("b =", b)
	print("args =", args)
	print("kwargs: ")
	for key, value in kwargs.items():
		print(key, "=", value)
 fun(1, 2, 3, 4, 5, m=6, n=7, p=8)	#调用
#参数也可通过名称赋值

函数的返回值

return：可返回单个值，也可返回多个值为元组

函数的嵌套调用

局部变量

全局变量

递归函数

匿名函数

1
2
lambda [arg1 [,arg2,.....argn]]:expression
sum = lambda arg1, arg2: arg1 + arg2

模块

模块可以从另外一个程序导入来使用其函数的功能。这也是我们使用 Python 标准库的方式。

1
2
3
4
5
6
7
8
#例：
import sys   #导入sys模块 
                
print('The command line arguments are:')
for i in sys.argv:
    print(i)

print('\n\nThe PYTHONPATH is', sys.path, '\n')

导入模块

在python中，有两种导入模块的方式：

  1. import 模块名
  2. from...import...

一般说来，应该避免使用 from..import 而使用 import 语句，因为这样可以使你的程序更加易读，也可以避免名称的冲突。

导入后可使用as为导入的模块添加别名

导入的原理

当 Python 执行import语句的时候，它会寻找要导入的模块。如果要导入内置模块，Python 知道在哪里找到它。

如果要导入的是未编译的模块，如用 Python 写的模块， Python 解释器会查找列在sys.path 变量中的路径。如果模块找到了，就会运行那个模块主体中的语句，模块就是可以利用的了。

初始化过程仅在我们第一次导入模块的时候进行。

.pyc文件

导入一个模块相对来说是一个比较费时的事情，所以 Python 做了一些技巧，以便使输入模块更加快一些。

一种方法是创建按字节编译的文件，这些文件以.pyc 作为扩展名。字节编译的文件与 Python 变换程序的中间状态有关。

当你在下次从别的程序输入这个模块的时候，.pyc 文件会快得多，因为一部分输入模块所需的处理已经完成了。另外，这些字节编译的文件也是与平台无关的。

这些.pyc 文件通常与.py 文件相同的方式在相同路径被创建。如果 Python 没有写入当前路径的权限，.pyc 文件就不会被创建。

模块的__name__

每个模块都有一个名称，在模块中可以通过语句来找出模块的名称。这在一个场合特别有用 —— 就如前面所提到的，当一个模块被第一次输入的时候，这个模块的主块将被运行。假如我们只想在程序本身被使用的时候运行主块，而在它被别的模块输入的时候不运行主块，我们该怎么做呢？这可以通过模块的 name 属性完成。

1
2
3
4
5
#每个 Python 模块都有它的 __name__，如果它是’__main__’，则说明这个模块被用户单独运行.
if __name__ == '__main__':
    print('This program is being run by itself')
else:
    print('I am being imported from another module')
1
2
3
4
5
6
$ python using_name.py
This program is being run by itself
$ python
>>> import using_name
I am being imported from another module
>>>

模块的__all__

如果一个文件中有__all__变量，那么也就意味着这个变量中的元素，不会被from xxx import *时导入

创建自己的模块

创建你自己的模块是十分简单的，你一直在这样做！每个 Python 程序就是一个模块。

dir 函数

你可以使用内建的 dir 函数来列出模块定义的标识符。标识符有函数、类和变量。
当你为 dir() 提供一个模块名的时候，它返回模块定义的名称列表。如果不提供参数，它返回当前模块中定义的名称列表。

1
2
3
4
5
# 在控制台使用(不是编辑器)
dir()
dir(sys)
dir(print)
dir(str)

包

包是模块的文件夹，有一个特殊的__init__.py文件，用来表明这个文件夹是特殊的因为其包含有 Python 模块。包仅仅是为了方便层次化地组织模块。你会看到在标准库中看到许多这样的实例.

模块的发布与安装

面向对象编程

类和对象

对象的属性

如果在属性名前面加了2个下划线’__’，则表明该属性是私有属性，否则为公有属性

对象的方法

成员方法

我们已经讨论了类/对象可以拥有像函数一样的方法，这些方法与函数的区别只是一个额外的 self 变量。

1
2
3
4
5
6
7
8
class Person:
    #创建一个成员方法
    #这里我们看到了 self 的用法。注意 sayHi 方法没有任何参数，但仍然在函数定义时有self。
    def sayHi(self):
        print('Hello, how are you?')

p = Person()
p.sayHi()

魔法方法

在python中方法名如果是__xxxx__()的，那么就有特殊的功能，因此叫做“魔法”方法。例如：当使用print输出对象的时候，只要自己定义了__str__(self)方法，那么就会打印从在这个方法中return的数据

  • __init__ 方法

__init__方法在类的一个对象被建立时，马上运行。这个方法可以用来对你的对象做一些你希望的初始化。

  • __new__方法

必须要有返回值，返回实例化出来的实例，这点在自己实现__new__时要特别注意，可以return父类__new__出来的实例，或者直接是object的__new__出来的实例

静态方法和类方法

继承

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
32
33
34
35
36
#例：
class SchoolMember:
    def __init__(self,name,age):
        self.name = name
        self.age = age
        print('(姓名:{0})'.format(self.name))
    
    def tell(self):
        print('Name:"{0}" Age:"{1}"'.format(self.name,self.age),end='')

class Teacher(SchoolMember):
    def __init__(self,name,age,salary):
        SchoolMember.__init__(self,name,age)
        self.salary = salary
        print('(老师:{0})'.format(self.name))
    
    def tell(self):
        SchoolMember.tell(self)
        print('Salary:"{0:d}"'.format(self.salary))

class Student(SchoolMember):
    def __init__(self,name,age,marks):
        SchoolMember.__init__(self,name,age)
        self.marks = marks
        print('(学生:{0})'.format(self.name))
        
    def tell(self):
        SchoolMember.tell(self)
        print('Marks:"{0:d}"'.format(self.marks))

t = Teacher('Mrs.Shrividya',30,30000)
s = Student('Swaroop',25,75)
print() #输出一个空行
members = [t,s]
for member in members:
    member.tell()

重写：就是子类中，有一个和父类相同名字的方法，在子类中的方法会覆盖掉父类中同名的方法

工厂模式

定义了一个创建对象的接口(可以理解为函数)，但由子类决定要实例化的类是哪一个，工厂方法模式让类的实例化推迟到子类，抽象的CarStore提供了一个创建对象的方法createCar，也叫作工厂方法。

1
2
3
4
5
6
7
8
9
10
class CarStore(object):
    #仅仅是定义了有这个方法，并没有实现，具体功能，这个需要在子类中实现
    def createCar(self, typeName):
        pass

    def order(self, typeName):
        # 让工厂根据类型，生产一辆汽车
        self.car = self.createCar(typeName)
        self.car.move()
        self.car.stop()

文件操作

文件

你可以创建一个 file 类的对象来打开文件，分别使用 file 类的read、readline 或 write 方法来恰当地读写文件。对文件的读写能力依赖于你在打开文件时指定的模式。最后，当你完成对文件的操作的时候，你调用close 方法来告诉 Python 我们完成了对文件的使用。

链接：文件操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
poem = '''
Programming is fun
When the work is done
if you wanna make your work also fun:
    use Python!
'''
#open()方法用于打开一个文件，并返回文件对象，如果该文件无法被打开，会抛出 OSError。
f = open('poem.txt', 'w')
#write()方法将字符串写入文件，返回的是写入的字符长度。
f.write(poem)
#close()方法关闭文件。关闭后文件不能再进行读写操作。
f.close()

f = open('poem.txt') #第二个参数默认为’r‘
while True:
    #readline()方法读取整行，包括 "\n" 字符。
    line = f.readline()
    if len(line) == 0:
        break
    #默认情况下，print() 函数将文本和自动生成的新行打印到屏幕。我们指定 end=”来制约新行的产生，因为从文件中读出的行已经用了换行符。
    print(line, end='')
f.close()

文件打开模式表：

访问模式 说明
r 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
w 打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
a 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
rb 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
wb 以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
ab 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
r+ 打开一个文件用于读写。文件指针将会放在文件的开头。
w+ 打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
a+ 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
rb+ 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
wb+ 以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
ab+ 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

pickle 模块

Python 提供了一个叫做 pickle 的标准模块，使用该模块你可以将任意对象存储在文件中，之后你又可以将其完整地取出来。这被称为持久地存储对象。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import pickle

shoplistfile = 'shoplist.data'

shoplist = ['apple','mango','carrot']
#二进制模式打开一个 file 对象，然后调用 pickle 模块的 dump 函数，这个过程称为 pickling 。
f = open(shoplistfile,'wb')
pickle.dump(shoplist, f) 
f.close()

del shoplist 

#用 pickle 模块的返回对象的 load 函数重新取回对象。这个过程称之为 unpickling 。
f = open(shoplistfile,'rb')
storedlist = pickle.load(f) 
print(storedlist)

文件的定位读写

在读写文件的过程中，如果想知道当前的位置，可以使用tell()来获取

如果在读写文件的过程中，需要从另外一个位置进行操作的话，可以使用seek()

seek(offset, from)有2个参数

  • offset:偏移量
  • from:方向
    • 0:表示文件开头
    • 1:表示当前位置
    • 2:表示文件末尾

文件的重命名、删除

os模块中的rename()可以完成对文件的重命名操作:rename(需要修改的文件名, 新的文件名)

os模块中的remove()可以完成对文件的删除操作:remove(待删除的文件名)

文件夹的相关操作

创建文件夹

1
2
import os
    os.mkdir("张三")

获取当前目录

1
2
import os
    os.getcwd()

改变默认目录

1
2
import os
    os.chdir("../")

获取目录列表

1
2
import os
   os.listdir("./")

删除文件夹

1
2
import os
   os.rmdir("张三")

异常处理

错误与异常

错误是无法通过其他代码进行处理问题，如语法错误和逻辑错误，语法错误是单词或格式等写错，只能根据系统提示去修改相应的代码，逻辑错误是代码实现功能的逻辑有问题，系统不会报错，也是只能找到相应的代码进行修改

异常是程序执行过程中，出现的未知问题，这里语法和逻辑都是正确的，可以通过其他代码进行处理修复，如可以通过if判定语句来避免对年龄进行赋值时输入了字符而出现异常的情况，如使用捕捉异常可以避免除零异常等。

异常处理

我们可以使用 try..except 语句来处理异常。我们把运行的语句放在 try-块中，把错误处理语句放在 except-块中。

try except 语句还有一个可选的else子句，如果使用这个子句，那么必须放在所有的except子句之后。这个子句将在try子句没有发生任何异常的时候执行。

Python 使用raise语句抛出一个指定的异常。

链接：详细

1
2
3
4
5
6
7
8
9
10
11
12
13
import sys
 
try:
    f = open('myfile.txt')
    s = f.readline()
    i = int(s.strip())
except OSError as err:
    print("OS error: {0}".format(err))
except ValueError:
    print("Could not convert data to an integer.")
except:
    print("Unexpected error:", sys.exc_info()[0])
    raise

try 语句还有另外一个可选的子句finally，它定义了无论在任何情况下都会执行的清理行为。

有一种 with 语句也能以清晰的方式完成这样的功能。

1
2
3
4
try:
    raise KeyboardInterrupt
finally:
    print('Goodbye, world!')
1
2
3
with open("poem.txt") as f:
    for line in f:
        print(line,end='')
打赏
  • 版权声明： 本博客所有文章除特别声明外，著作权归作者所有。转载请注明出处！
  • © 2020 h0ryit
  • PV: UV:

请我喝杯咖啡吧~

支付宝
微信