Python语法基础

时间 2019-11-17

标签 python 语法基础栏目 Python 繁體版

原文原文链接

设置环境变量python

Linux：
$ PATH=$PATH:/usr/local/python3/bin/python3    # 设置环境变量
$ python3 --version
Python 3.4.0

Windows:
set path=%path%;C:\python34

一、在Linux下使用下面的代码能够直接./xxx.py执行脚本，在Windows下不能够：#!/usr/bin/python3express

二、执行脚本：$ python3 hello.pyjson

三、字符编码，须要写在文件的开头，好比支持中文编码：
# -*- coding: UTF-8 -*- 或者 #coding=utf-8，函数

#coding=utf-8

import json  

student = {}
student['Name'] = '张三'
student['Age'] = 18
student[12] = True

print json.dumps(student, ensure_ascii=False, encoding='utf-8')

注意：#coding=utf-8 的 = 号两边不要空格，且utf-8必须为小写。工具

四、关键字：>>> import keyword，>>> keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', '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']测试

五、代码注释：#!/usr/bin/python3，也可使用''' XXX'''和"""XXX"""，即连续的3个单引号或双引号ui

#单引号注释
#!/usr/bin/python3 
'''
这是多行注释，用三个单引号
这是多行注释，用三个单引号 
这是多行注释，用三个单引号
'''
print("Hello, World!") 

#双引号注释
#!/usr/bin/python3 
"""
这是多行注释，用三个单引号
这是多行注释，用三个单引号 
这是多行注释，用三个单引号
"""
print("Hello, World!")

六、代码块：python最具特点的就是使用缩进来表示代码块，不须要使用大括号({})。缩进的空格数是可变的，可是同一个代码块的语句必须包含相同的缩进空格数，缩进不一致，会致使运行错误。this

七、多行语句：使用反斜杠(\)来实现多行语句，在 [], {}, 或 () 中的多行语句，不须要使用反斜杠(\)：编码

total = item_one + \
        item_two + \
        item_three
在 [], {}, 或 () 中的多行语句，不须要使用反斜杠(\)，例如：
total = ['item_one', 'item_two', 'item_three',
        'item_four', 'item_five']

注意！多行的内容都属于同一块，所以缩进必定要一致。.net

八、数据类型：python中数有四种类型：整数、长整数、浮点数和复数。
整数，如 1
长整数是比较大的整数
浮点数如 1.2三、3E-2
复数如 1 + 2j、 1.1 + 2.2j

九、字符串：python中单引号和双引号使用彻底相同。使用三引号('''或""")能够指定一个多行字符串。
转义符 '\'天然字符串，经过在字符串前加r或R。如 r"this is a line with \n" 则\n会显示，并非换行。
python容许处理unicode字符串，加前缀u或U，如 u"this is an unicode string"。
字符串是不可变的。按字面意义级联字符串，如"this " "is " "string"会被自动转换为this is string。
word = '字符串'
sentence = "这是一个句子。"
paragraph = """这是一个段落，
能够由多行组成"""

十、代码组：

if expression : 
   suite
elif expression : 
   suite 
else : 
   suite

十一、换行输出：print("xxx")，
不换行输出：print( x, end=" " )或
print( y, end="END" )
print(a, b, c, d, e, sep='+')，输出abcde并使用+号链接。

十二、导入模块：

将整个模块(somemodule)导入，格式为： import somemodule
从某个模块中导入某个函数,格式为： from somemodule import somefunction
从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc
将某个模块中的所有函数导入，格式为： from somemodule import *

1三、help() 函数：调用 python 的 help() 函数能够打印输出一个函数的文档字符串，按下 : q 两个按键即退出说明文档

1四、多个变量同时赋值：a, b, c = 1, 2, "runoob"

1五、Python3 中有六个标准的数据类型：
        Number（数字）
        String（字符串）
        List（列表）
        Tuple（元组）
        Sets（集合）
        Dictionary（字典）

1六、Python3 支持 int、float、bool、complex。内置的 type() 函数能够用来查询变量所指的对象类型：

type()来判断数据的类型：
>>> a, b, c, d = 20, 5.5, True, 4+3j
>>> print(type(a), type(b), type(c), type(d))
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>
能够用 isinstance 来判断：
>>>a = 111
>>> isinstance(a, int)
True
>>>
isinstance 和 type 的区别在于：
class A:
    pass

class B(A):
    pass

isinstance(A(), A)  # returns True
type(A()) == A      # returns True
isinstance(B(), A)    # returns True
type(B()) == A        # returns False
区别就是:
type()不会认为子类是一种父类类型。
isinstance()会认为子类是一种父类类型。

1七、字符串：Python中的字符串用单引号(')或双引号(")括起来，同时使用反斜杠(\)转义特殊字符：

str = 'Runoob'
print (str)          # 输出字符串
print (str[0:-1])    # 输出第一个到倒数第二个的全部字符
print (str[0])       # 输出字符串第一个字符
print (str[2:5])     # 输出从第三个开始到第五个的字符
print (str[2:])      # 输出从第三个开始的后的全部字符
print (str * 2)      # 输出字符串两次
print (str + "TEST") # 链接字符串

字符串的这种输出方式一样适用于列表等其余集合数据类型。与 C 字符串不一样的是，Python 字符串不能被改变。向一个索引位置赋值，好比word[0] = 'm'会致使错误。

1八、列表：列表支持使用不一样的数据类型组成同一个列表：

#!/usr/bin/python3
 
list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
tinylist = [123, 'runoob']
 
print (list)            # 输出完整列表
print (list[0])         # 输出列表第一个元素
print (list[1:3])       # 从第二个开始输出到第三个元素
print (list[2:])        # 输出从第三个元素开始的全部元素
print (tinylist * 2)    # 输出两次列表
print (list + tinylist) # 链接列表

与Python字符串不同的是，列表中的元素是能够改变的：

1九、元组：元组与列表相似，不一样之处在于元组的元素不能修改：

#!/usr/bin/python3
 
tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2  )
tinytuple = (123, 'runoob')
 
print (tuple)             # 输出完整元组
print (tuple[0])          # 输出元组的第一个元素
print (tuple[1:3])        # 输出从第二个元素开始到第三个元素
print (tuple[2:])         # 输出从第三个元素开始的全部元素
print (tinytuple * 2)     # 输出两次元组
print (tuple + tinytuple) # 链接元组

20、集合：是一个无序不重复元素的序列：

#!/usr/bin/python3
 
student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}
 
print(student)   # 输出集合，重复的元素被自动去掉
 
# 成员测试
if('Rose' in student) :
    print('Rose 在集合中')
else :
    print('Rose 不在集合中')
 
 
# set能够进行集合运算
a = set('abracadabra')
b = set('alacazam')
 
print(a)
 
print(a - b)     # a和b的差集
 
print(a | b)     # a和b的并集
 
print(a & b)     # a和b的交集
 
print(a ^ b)     # a和b中不一样时存在的元素

注意：建立一个空集合必须用 set() 而不是 { }，由于 { } 是用来建立一个空字典。

2一、字典：是经过key-value来存取数据：

#!/usr/bin/python3
 
dict = {}
dict['one'] = "1 - 菜鸟教程"
dict[2]     = "2 - 菜鸟工具"
 
tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}
 
 
print (dict['one'])       # 输出键为 'one' 的值
print (dict[2])           # 输出键为 2 的值
print (tinydict)          # 输出完整的字典
print (tinydict.keys())   # 输出全部键
print (tinydict.values()) # 输出全部值

输出结果：

1 - 菜鸟教程
2 - 菜鸟工具
{'name': 'runoob', 'site': 'www.runoob.com', 'code': 1}
dict_keys(['name', 'site', 'code'])
dict_values(['runoob', 'www.runoob.com', 1])

注意：

一、字典是一种映射类型，它的元素是键值对。

二、字典的关键字必须为不可变类型，且不能重复。

三、建立空字典使用 { }。

四、不容许同一个键出现两次。建立时若是同一个键被赋值两次，后一个值会被记住

五、键必须不可变，因此能够用数字，字符串或元组充当，而用列表就不行

字典是支持无限极嵌套的，以下面代码：

citys={
    '北京':{
        '朝阳':['国贸','CBD','天阶','我爱我家','连接地产'],
        '海淀':['圆明园','苏州街','中关村','北京大学'],
        '昌平':['沙河','南口','小汤山',],
        '怀柔':['桃花','梅花','大山'],
        '密云':['密云A','密云B','密云C']
    },
    '河北':{
        '石家庄':['石家庄A','石家庄B','石家庄C','石家庄D','石家庄E'],
        '张家口':['张家口A','张家口B','张家口C'],
        '承德':['承德A','承德B','承德C','承德D']
    }
}

可使用以下方法进行列出:

for i in citys['北京']:
    print(i)

将列出以下结果：

朝阳
海淀
昌平
怀柔
密云

for i in citys['北京']['海淀']:
    print(i)

输出以下结果：

圆明园
苏州街
中关村
北京大学

2二、数据类型转换：

int(x [,base])将x转换为一个整数
float(x)将x转换到一个浮点数
complex(real [,imag])建立一个复数
str(x)将对象 x 转换为字符串
repr(x)将对象 x 转换为表达式字符串
eval(str)用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s)将序列 s 转换为一个元组
list(s)将序列 s 转换为一个列表
set(s)转换为可变集合
dict(d)建立一个字典。d 必须是一个序列 (key,value)元组。
frozenset(s)转换为不可变集合
chr(x)将一个整数转换为一个字符
ord(x)将一个字符转换为它的整数值
hex(x)将一个整数转换为一个十六进制字符串
oct(x)将一个整数转换为一个八进制字符串

2三、python 使用 lambda 来建立匿名函数。

所谓匿名，意即再也不使用 def 语句这样标准的形式定义一个函数。

lambda 只是一个表达式，函数体比 def 简单不少。
lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
lambda 函数拥有本身的命名空间，且不能访问本身参数列表以外或全局命名空间里的参数。
虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增长运行效率。

#!/usr/bin/python3
 
# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2;
 
# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))

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

>>> def test():
...     msg_inner = 'I am from Runoob'

>>> if True:
...  msg = 'I am from Runoob'
... 
>>> msg
'I am from Runoob'
>>>

在if中定义的变量msg能够在外部继续访问，而定义在函数test()内的msg_inner变量只能在函数内访问。

2五、遍历字典和列表

#字典遍历
knights = {'gallahad': 'the pure', 'robin': 'the brave'}
#遍历keys
for a in knights.keys():
	print(a)
#遍历values
for a in knights.values():
	print(a)
#同时遍历keys和values
for k, v in knights.items():
	print(k, v, sep=':')
	
#列表遍历
mylst = ['tic', 'tac', 'toe']
for a in mylst :
	print(a)
#遍历列表和索引
for i, v in enumerate(mylst):
	print(i, v, sep=':')
#反向遍历列表
for v in reversed(mylst):
	print(v)
#遍历排序后的列表
for v in sorted(mylst):
	print(v)

2六、文件读写

cities = {
	'北京':{
		'海淀区',
		'朝阳区'
	},
	'广州':{
		'番禺区',
		'海珠区'
	}
}

# 打开一个文件
f = open("temp.txt", "w")
s = str(cities)

#写入数据到文件
f.write(s)

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

#打开读取文件
f2 = open("temp.txt", "r")

#读取所有行
print(f2.readlines())

#关闭读取文件
f2.close()

2七、对象序列化和反序列化

#对象序列化
import pickle

# 使用pickle模块将数据对象保存到文件
data1 = {'a': [1, 2.0, 3, 4+6j],
         'b': ('string', u'Unicode string'),
         'c': None}

selfref_list = [1, 2, 3]

output = open('data.pkl', 'wb')

# Pickle dictionary using protocol 0.
pickle.dump(data1, output)

# Pickle the list using the highest protocol available.
pickle.dump(selfref_list, output, -1)

output.close()


#对象反序列化，使用pprint和print好像同样？
import pprint, pickle

#使用pickle模块从文件中重构python对象
pkl_file = open('data.pkl', 'rb')

data1 = pickle.load(pkl_file)
pprint.pprint(data1)
print(data1)

data2 = pickle.load(pkl_file)
pprint.pprint(data2)
print(data2)

pkl_file.close()

2八、异常处理try..exception..finally

import sys

#自定义异常处理类
class MyError(Exception):
	def __init__(self, value):
		self.value = value
	def __str__(self):
		return repr(self.value)
			
#产生异常的除法函数
def DivNum(x, y):
	if y == 0:
		raise NameError('除数不能为零') #除数为零抛出异常
	elif y < 0:
		raise MyError("除数不能小于零")
	else:
		return x / y;

try:
	f = DivNum(10, -1)
	print(f)
except NameError as err:
	print("OS error: {0}".format(err))
except ValueError:
    print("Could not convert data to an integer.")
except:  #或者使用else:
	print("Unexpected error:", sys.exc_info()[0], sys.exc_info()[1])
finally: #最后都会执行的代码
	print("到此一游！")
	
#除了可使用finally进行异常清理
#还可使用with语句进行预处理清理
with open("myfile.txt") as f:
    for line in f:
        print(line, end="")

2九、类的定义和使用

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部没法直接进行访问，使用两根下划线
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
 
#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
 
#另外一个类，多重继承以前的准备
class speaker():
    topic = ''
    name = ''
    def __init__(self,n,t):
        self.name = n
        self.topic = t
    def speak(self):
        print("我叫 %s，我是一个演说家，我演讲的主题是 %s"%(self.name,self.topic))
 
#多重继承
class sample(speaker,student):
    a =''
    def __init__(self,n,a,w,g,t):
        student.__init__(self,n,a,w,g)
        speaker.__init__(self,n,t)
    def __add(self):  #类的私有方法和私有变量同样使用两根下划线命名
        print("add")
 
test = sample("Tim",25,80,4,"Python")
test.speak()   #方法名同，默认调用的是在括号中排前地父类的方法
#test.__add()  #类的私有方法不能在类的外部调用

30、类的专有方法和运算符重载，参考：http://www.jb51.net/article/59691.htm

__init__ : 构造函数，在生成对象时调用
__del__ : 析构函数，释放对象时使用
__repr__ : 打印，转换
__str__：打印类自身
__setitem__ : 按照索引赋值
__getitem__: 按照索引获取值
__len__: 得到长度
__cmp__: 比较运算
__call__: 函数调用
__add__: 加运算
__sub__: 减运算
__mul__: 乘运算
__div__: 除运算
__mod__: 求余运算
__pow__: 乘方


#重载操做符至关于重写上面的专有方法
class Vector:
   def __init__(self, a, b):
      self.a = a
      self.b = b
 
   def __str__(self):
      return 'Vector (%d, %d)' % (self.a, self.b)
   
   def __add__(self,other):
      return Vector(self.a + other.a, self.b + other.b)
 
v1 = Vector(2,10)
v2 = Vector(5,-2)
print (v1 + v2)