Python学习6_Python基础

转载自https://blog.youkuaiyun.com/weixin_39202006/article/details/79107087

Python中默认的编码格式是 ASCII格式，在没修改编码格式时无法正确打印汉字，所以在读取中文时会报错。

解决方法为只要在文件开头加入 # -*-coding: UTF-8 -*- 或者 #coding=utf-8 就行了

注意：#coding=utf-8 的 = 号两边不要空格。

注意：Python3.X源码文件默认使用utf-8编码，所以可以正常解析中文，无需指定 UTF-8编码。

 

所有 Python文件将以 .py 为扩展名。

 

Python 标识符

在 Python里，标识符由字母、数字、下划线组成。

在 Python中，所有标识符可以包括英文、数字以及下划线(_)，但不能以数字开头。

Python 中的标识符是区分大小写的。

以下划线开头的标识符是有特殊意义的。以单下划线开头 _foo 的代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用 from xxx import * 而导入；

以双下划线开头的 __foo 代表类的私有成员；以双下划线开头和结尾的 __foo__ 代表 Python 里特殊方法专用的标识，如 __init__() 代表类的构造函数。

Python 可以同一行显示多条语句，方法是用分号 ; 分开

 

 

Python 保留字符

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

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

and	exec	not
assert	finally	or
break	for	pass
class	from	print
continue	global	raise
def	if	return
del	import	try
elif	in	while
else	is	with
except	lambda	yield

 

 

多行语句

Python语句中一般以新行作为为语句的结束符。

但是我们可以使用斜杠（ \）将一行的语句分为多行显示，如下所示：

total = item_one + \

       item_two + \

       item_three

语句中包含 [], {}或 () 括号就不需要使用多行连接符。如下实例：

days = ['Monday','Tuesday', 'Wednesday',

       'Thursday','Friday']

 

 

Python 引号

Python 可以使用引号( ' )、双引号( " )、三引号( ''' 或 """ )来表示字符串，引号的开始与结束必须的相同类型的。

其中三引号可以由多行组成，编写多行文本的快捷语法，常用于文档字符串，在文件的特定地点，被当做注释。

word = 'word'

sentence = "这是一个句子。"

paragraph = """这是一个段落。

包含了多个语句"""

 

Python注释

python中单行注释采用 #开头。

python 中多行注释使用三个单引号(''')或三个双引号(""")。

#!/usr/bin/python

# -*- coding: UTF-8 -*-

# 文件名：test.py

 

 

'''

这是多行注释，使用单引号。

这是多行注释，使用单引号。

这是多行注释，使用单引号。

'''

 

"""

这是多行注释，使用双引号。

这是多行注释，使用双引号。

这是多行注释，使用双引号。

"""

 

 

Python空行

函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。

空行与代码缩进不同，空行并不是Python语法的一部分。书写时不插入空行，Python解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构。

记住：空行也是程序代码的一部分。

 

 

Print 输出

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

# 不换行输出

print x,

print y,

 

 

变量赋值

Python 中的变量赋值不需要类型声明。

每个变量在内存中创建，都包括变量的标识，名称和数据这些信息。

每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

等号（=）用来给变量赋值。

等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值。

 

 

多个变量赋值

Python允许你同时为多个变量赋值。例如：

a = b = c = 1

以上实例，创建一个整型对象，值为1，三个变量被分配到相同的内存空间上。

您也可以为多个对象指定多个变量。例如：

a, b, c = 1, 2,"john"

以上实例，两个整型对象1和2的分配给变量 a和 b，字符串对象 "john"分配给变量 c。

 

 

标准数据类型

在内存中存储的数据可以有多种类型。

例如，一个人的年龄可以用数字来存储，他的名字可以用字符来存储。

Python 定义了一些标准类型，用于存储各种类型的数据。

Python有五个标准的数据类型：

·        Numbers（数字）

·        String（字符串）

·        List（列表）

·        Tuple（元组）

·        Dictionary（字典）

 

Python数字

数字数据类型用于存储数值。

他们是不可改变的数据类型，这意味着改变数字数据类型会分配一个新的对象。

当你指定一个值时，Number对象就会被创建：

var1 = 1
var2 = 10

您也可以使用del语句删除一些对象的引用。

del语句的语法是：

delvar1[,var2[,var3[....,varN]]]]

您可以通过使用del语句删除单个或多个对象的引用。例如：

del var
del var_a, var_b

Python支持四种不同的数字类型：

·        int（有符号整型）

·        long（长整型[也可以代表八进制和十六进制]）

·        float（浮点型）

·        complex（复数）

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

 

Python字符串

字符串或串(String)是由数字、字母、下划线组成的一串字符。

python的字串列表有2种取值顺序:

·        从左到右索引默认0开始的，最大范围是字符串长度少1

·        从右到左索引默认-1开始的，最大范围是字符串开头

如果你要实现从字符串中获取一段子字符串的话，可以使用变量 [头下标:尾下标]，就可以截取相应的字符串，其中下标是从 0 开始算起，可以是正数或负数，下标可以为空表示取到头或尾。

比如:

s ='ilovepython'

s[1:5]的结果是love。

加号（+）是字符串连接运算符，星号（*）是重复操作

printstr[2:]#输出从第三个字符开始的字符串

printstr *2# 输出字符串两次

printstr +"TEST"#输出连接的字符串

 

Python列表

List（列表）是 Python中使用最频繁的数据类型。

list = ['runoob',786 , 2.23,'john',70.2]

 

Python元组

元组是另一个数据类型，类似于List（列表）。

元组用"()"标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。

tuple = ('runoob',786 , 2.23,'john',70.2)

 

Python 字典

字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。列表是有序的对象集合，字典是无序的对象集合。

两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

字典用"{ }"标识。字典由索引(key)和它对应的值value组成。

dict = {}

dict['one'] ="This is one"

dict[2] ="This is two"

tinydict = {'name':'john','code':6734,'dept':'sales'}

 

printdict['one']#输出键为'one' 的值

printdict[2]#输出键为 2 的值

printtinydict#输出完整的字典

printtinydict.keys()#输出所有键

printtinydict.values()#输出所有值

 

Python数据类型转换

有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。

以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值。

 

Python算术运算符

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

运算符	描述	实例
+	加 -两个对象相加	a + b 输出结果 30
-	减 -得到负数或是一个数减去另一个数	a - b 输出结果 -10
*	乘 -两个数相乘或是返回一个被重复若干次的字符串	a * b 输出结果 200
/	除 - x除以y	b / a 输出结果 2
%	取模 -返回除法的余数	b % a 输出结果 0
**	幂 -返回x的y次幂	a**b 为10的20次方，输出结果 100000000000000000000
//	取整除 -返回商的整数部分	9//2 输出结果 4 , 9.0//2.0输出结果 4.0

 

Python赋值运算符

以下假设变量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

 

Python逻辑运算符

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 是非 0，它返回 x的值，否则它返回 y 的计算值。	(a or b) 返回 10。
not	not x	布尔"非" -如果 x 为 True，返回 False。如果 x 为 False，它返回 True。	not(a and b) 返回 False

 

Python成员运算符

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

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

 

Python身份运算符

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

运算符	描述	实例
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。

注： id() 函数用于获取对象内存地址。

is 与 ==区别：

is 用于判断两个变量引用对象是否为同一个， ==用于判断引用变量的值是否相等。

 

Python提供了for循环和while循环（在Python中没有do..while循环）:

循环类型	描述
while循环	在给定的判断条件为 true时执行循环体，否则退出循环体。
for循环	重复执行语句
嵌套循环	你可以在while循环体中嵌套for循环

 

 

循环控制语句

循环控制语句可以更改语句执行的顺序。Python支持以下循环控制语句：

控制语句	描述
break语句	在语句块执行过程中终止循环，并且跳出整个循环
continue语句	在语句块执行过程中终止当前循环，跳出该次循环，执行下一次循环。
pass语句	pass是空语句，是为了保持程序结构的完整性。

 

循环使用 else语句

在 python中，while … else在循环条件为 false时执行 else 语句块：

实例

#!/usr/bin/pythoncount =0whilecount <5: printcount," is less than 5"count =count + 1else:printcount,"is not less than 5"

 

循环使用 else语句

在 python中，for … else表示这样的意思，for中的语句和普通的没有区别，else中的语句会在循环正常执行完（即 for不是通过 break 跳出而中断的）的情况下执行，while … else也是一样。

实例

fornuminrange(10,20):# 迭代 10到 20 之间的数字

foriinrange(2,num):# 根据因子迭代

ifnum%i ==0: #确定第一个因子

j=num/i#计算第二个因子

print'%d等于 %d * %d' %(num,i,j)

break#跳出当前循环

else: # 循环的 else部分

printnum,'是一个质数'

 

创建类

使用 class 语句来创建一个新类，class 之后为类的名称并以冒号结尾:

class ClassName:

   '类的帮助信息'   #类文档字符串

   class_suite  #类体

类的帮助信息可以通过ClassName.__doc__查看。

class_suite 由类成员，方法，数据属性组成。

 

self代表类的实例，而非类

类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称,按照惯例它的名称是 self。

classTest:

defprt(self):

print(self)

print(self.__class__)

 

t = Test()

t.prt()

 

单下划线、双下划线、头尾双下划线说明：

·        __foo__:定义的是特殊方法，一般是系统定义名字，类似 __init__() 之类的。

·        _foo:以单下划线开头的表示的是 protected类型的变量，即保护类型只能允许其本身与子类进行访问，不能用于 from moduleimport *

·        __foo:双下划线的表示的是私有类型(private)的变量,只能是允许这个类本身进行访问了

 

Python pass语句

Python pass是空语句，是为了保持程序结构的完整性。

pass 不做任何事情，一般用做占位语句。

 

Python随机数函数

随机数可以用于数学，游戏，安全等领域中，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性。

Python包含以下常用随机数函数：

函数	描述
choice(seq)	从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。
randrange ([start,] stop [,step])	从指定范围内，按指定基数递增的集合中获取一个随机数，基数缺省值为1
random()	随机生成下一个实数，它在[0,1)范围内。
seed([x])	改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。
shuffle(lst)	将序列的所有元素随机排序
uniform(x, y)	随机生成下一个实数，它在[x,y]范围内。

 

Python转义字符

在需要在字符中使用特殊字符时，python用反斜杠(\)转义字符。如下表：

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

 

print "My name is %s and weight is %d kg!" % ('Zara', 21) 

 

Python三引号（triple quotes）

python中三引号可以将复杂的字符串进行复制:

python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。

三引号的语法是一对连续的单引号或者双引号（通常都是成对的用）。

 

Python列表脚本操作符

列表对 +和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。

如下所示：

Python 表达式	结果	描述
len([1, 2, 3])	3	长度
[1, 2, 3] + [4, 5, 6]	[1, 2, 3, 4, 5, 6]	组合
['Hi!'] * 4	['Hi!', 'Hi!', 'Hi!', 'Hi!']	重复
3 in [1, 2, 3]	True	元素是否存在于列表中
for x in [1, 2, 3]: print x,	1 2 3	迭代

 

Python 元组

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

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

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

 

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

tup1 = (50,);

 

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

#!/usr/bin/python

# -*- coding: UTF-8 -*-

 

# 可写函数说明

def printinfo( arg1, *vartuple ):

   "打印任何传入的参数"

   print "输出: "

   print arg1

   for var in vartuple:

      print var

   return;

 

# 调用printinfo 函数

printinfo( 10 );

printinfo( 70, 60, 50 );

 

匿名函数

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

语法

lambda函数的语法只包含一个语句，如下：

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

如下实例：

#!/usr/bin/python

# -*- coding: UTF-8 -*-

 

# 可写函数说明

sum = lambda arg1, arg2: arg1 + arg2;

 

# 调用sum函数

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

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

以上实例输出结果：

相加后的值为 :  30

相加后的值为 :  40

 

Python 模块

Python 模块(Module)，是一个Python文件，以 .py 结尾，包含了 Python 对象定义和Python语句。

模块让你能够有逻辑地组织你的 Python代码段。

 

From…import 语句

Python 的 from语句让你从模块中导入一个指定的部分到当前命名空间中。语法如下：

from modname import name1[, name2[, ... nameN]]

例如，要导入模块 fib 的 fibonacci 函数，使用如下语句：

from fib import fibonacci

 

dir()函数

dir() 函数一个排好序的字符串列表，内容是一个模块里定义过的名字。

返回的列表容纳了在一个模块里定义的所有模块，变量和函数。如下一个简单的实例：

#!/usr/bin/python

# -*- coding: UTF-8 -*-

 

# 导入内置math模块

import math

 

content = dir(math)

 

print content;

 

reload() 函数

当一个模块被导入到一个脚本，模块顶层部分的代码只会被执行一次。

因此，如果你想重新执行模块里顶层部分的代码，可以用 reload()函数。该函数会重新导入之前导入过的模块。语法如下：

reload(module_name)

在这里，module_name要直接放模块的名字，而不是一个字符串形式。比如想重载hello模块，如下：

reload(hello)

 

Python中的包

包是一个分层次的文件目录结构，它定义了一个由模块及子包，和子包下的子包等组成的 Python的应用环境。

简单来说，包就是文件夹，但该文件夹下必须存在 __init__.py文件, 该文件的内容可以为空。__int__.py用于标识当前文件夹是一个包。

 

 

Python 异常处理

以下为单个异常的实例：

#!/usr/bin/python

# -*- coding: UTF-8 -*-

 

# 定义函数

deftemp_convert(var):

    try:

       return int(var)

    except ValueError, Argument:

       print "参数没有包含数字\n",Argument

 

# 调用函数

temp_convert("xyz");

 

 

Python内置类属性

·        __dict__ :类的属性（包含一个字典，由类的数据属性组成）

·        __doc__ :类的文档字符串

·        __name__:类名

·        __module__:类定义所在的模块（类的全名是'__main__.className'，如果类位于一个导入模块mymod中，那么className.__module__等于 mymod）

·        __bases__ :类的所有父类构成元素（包含了一个由所有父类组成的元组）

 

实例

析构函数 __del__ ，__del__在对象销毁的时候被调用，当对象不再被使用时，__del__方法运行

 

 

类的继承

面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制。继承完全可以理解成类之间的类型和子类型关系。

需要注意的地方：继承语法 class派生类名（基类名）：//...基类名写在括号里，基本类是在类定义的时候，在元组之中指明的。

在python中继承中的一些特点：

·        1：在继承中基类的构造（__init__()方法）不会被自动调用，它需要在其派生类的构造中亲自专门调用。

·        2：在调用基类的方法时，需要加上基类的类名前缀，且需要带上self参数变量。区别在于类中调用普通函数时并不需要带上self参数

·        3：Python总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。（先在本类中查找调用的方法，找不到才去基类中找）。

 

实例

#!/usr/bin/python

# -*- coding: UTF-8 -*-

classParent:# 定义父类

parentAttr =100

def__init__(self):

print("调用父类构造函数")

 

def parentMethod(self):

print('调用父类方法')

 

def setAttr(self,attr):

Parent.parentAttr =attr

 

def getAttr(self):

print("父类属性 :",Parent.parentAttr)

 

class Child(Parent):

# 定义子类

def __init__(self):

print("调用子类构造方法" )

 

def childMethod(self):

print('调用子类方法')

 

c =Child()

#实例化子类

c.childMethod()

#调用子类的方法

c.parentMethod()

#调用父类方法

c.setAttr(200)

#再次调用父类的方法 -设置属性值

c.getAttr()

#再次调用父类的方法 -获取属性值

 

以上代码执行结果如下：

调用子类构造方法

调用子类方法

调用父类方法

父类属性 : 200

你可以继承多个类

class A:        # 定义类 A

.....

 

class B:         # 定义类 B

.....

 

class C(A, B):   # 继承类 A 和 B

.....