python要点简要-一日精通python

Python2.x是历史，Python3.x是这门语言的现在和未来。Python2和3大约90%的地方都很相似的。

1、注释

单行注释：在注释的前面输入#号，如下：

# 这是一条注释

多行注释：使用三个单引号或者三个双引号来添加多行注释：

'''
这是一条注释
还可以再加一条注释
'''

2、变量

变量是我们需要存储和操作数据的名字，定义一个新变量之后，需要给它赋一个初始的值。在后续的程序中还是可以修改这个值

userAge, userName = 30, 'Peter'
#等同于以下
userAge = 30
userName = 'Peter'

2.1 变量命名

1）变量名仅可以包含字母(a-z,A-Z)，数字或者下划线(_)

2）第一个字符不能是数字

3）大小写敏感

4）不能使用Python中预留的词语

5）命名规则：

        驼峰式：单词组合在一起，并且混合大小写，一般是每个单词的第一个字母都是大写，其他小写，例如userAge。一般采用的方式。

        下划线(_)：利用下划线将每个单词分开，例如user_age。

2.2 赋值符号(=)

在程序中，x = y 和 y = x 有着不同的含义

x = 5
y = 10
x = y
print("x = ", x)   # output：10
print("y = ", y)   # output：10

x = 5
y = 10
y = x
print("x = ", x)   # output：5
print("y = ", y)   # output：5

2.3 基本操作符

基本操作符：+、—、*、/、//、%和**

分别表示：加、减、乘、除、整除、取余和指数

x = 5
y = 2

# 加法
x + y        # 7

# 减法
x - y        # 2

#乘法
x * y        # 10

# 除法
x / y        # 2.5

# 整除（向最近的整数向下取整）
x // y       #2

# 取余（余数）
x % y        # 1(当5除以2时得到的余数) 

# 指数
x ** y       # 25 (5的2次方)

2.4 更多操作符

表示自增、自减和自乘，如+=、-=和*=这样的操作符。x = x + 2可以写成有相同含义的x += 2。

3、Python中的数据类型

基本的类型有整数、浮点数和字符串，以及这些类型之间的转化。

高级的数据类型有列表、元组和字典。

3.1 整型

没有小数部分的数字，比如-5，0，5，7等。

userAge = 10

3.2 浮点型

带有小数点部分的数字，比如1.234等。

userHeight = 1.82

3.3 字符串

表示文本，可以使用单引号或者双引号来声明。可以使用连接符号(+)来连接多个字符号，比如'Peter' + 'Lee'等于字符串'PeterLee'。

userName = 'Peter'

3.3.1 内嵌的字符串函数（大小写敏感）

1、upper()，将字符串中每个字符都变成大写。比如，'Peter'.upper()得到'PETER'。

2、lower()：将字符串变为小写。

3、count(sub, [start, [end]])，返回子字符串sub在字符串中出现的次数。[start, [end]]表示的是开始和结束是可选择的参数。

>>> 'This is a string'.count('s')  # 计算's'在字符串中出现的次数
3
>>> 'This is a string'.count('s', 4)  # 计算从索引4到字符串的结尾
2

4、endswith(suffix, [start, [end]])，如果字符串以指定的后缀suffix结尾，就返回True。

>>> 'Postman'.endswith('man')  # 检查整个字符串
True
>>> 'Postman'.endswith('man',2, 6)  # 检查索引2到6-1的位置
False
>>> 'Postman'.endswith(('man','ma'), 2, 6)  # 使用一个后缀的元组（从索引2到6-1的位置检索）
True

5、startswith(prefix[, start[, end]])：如果字符串以前缀prefix开始，则返回True，否则False。

>>> 'Postman'.startswith('Post')
True
>>> 'Postman'.startswith('Post', 3)
False

6、find/index(sub, [start, [end]])，返回字符串中子字符串sub首次出现的索引位置。

find()在无法找到sub是返回-1；index()在无法找到sub时返回ValueError。

>>> 'This is a string'.find('s')  
3
>>> 'This is a string'.index('s')
3
>>> 'This is a string'.find('p')
-1
>>> 'This is a string'.index('p')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found

7、isalnum()：判断字符串是否都是字母和数字。

8、isalpha()：判断字符串是否都是字母。

9、isdigit()：判断字符串是否都是数字。

10、islower()：判断字符串是否都是小写

11、isspace()：判断字符串是否都是空格

12、istitle()：判断字符串是否都是首字母大写。

13、isupper()：判断字符串是否都是大写。

14、join()：使用分隔符号把提供的参数连接成一个字符串并返回。

>>> sep='-'
>>> myTuple = ('a', 'b', 'c')
>>> myList = ['d', 'e', 'f']
>>> sep.join(myTuple)
'a-b-c'
>>> sep.join(myList)
'd-e-f'

15、replace(old, new[, count])：将字符串中所有的old字符串替换为new字符串，仅仅替换前面count次数出现的字符串会被替换。

>>> 'This is a string'.replace('s', 'p')
'Thip ip a ptring'
>>> 'This is a string'.replace('s', 'p', 2)
'Thip ip a string'

16、split([sep[, maxsplit]])：使用sep作为分隔符，返回一个单词的列表。若sep没有指定，则分隔符默认为空格（包括空字符、 、 等），如果指定maxsplit，则最多会做maxsplit次分割。

>>> s = "I am, writing
python	book on line"
>>> print(s)
I am, writing
python    book on line
>>> s.split()
['I', 'am,', 'writing', 'python', 'book', 'on', 'line']

17、splitlines([keepends])：返回字符串所有行的列表，以每行的边界符来分隔。

18、strip([chars])：移除字符串首尾位置char。如果没有指定char，则移除空格。另外还有lstrip()移除左边的字符，rstrip()移除右边的字符。

3.3.2 使用%操作符格式化字符串

该语法包含三部分：首先是要格式化的字符串，包含占位符%s,%f,%d等；其次是%；最后是字符串的变量，使用小括号包含多个值（元组）

brand = 'Apple'
exchangeRate = 1.23241
message = 'The price of this %s laptop is %d USD and the exchange 
           rate is %4.2f USD to 1 ESR' % (brand, 1299, exchangeRate)

print(message)
# The price of this Apple laptop is 1299 USD and the exchange rate is 1.23 USD to 1 ESR

%s表示字符串；

%d表示一个整数，%5d表示字符串长度为5的数字，如"%5d" % (123)将显示"  123"；

%f浮点数，%4.2f表示总长度为4位，2表示2个小数位。

3.3.3 使用format()方法格式化字符串

 使用大括号{}作为占位符，在{}内首先写下使用的参数的位置（第几个参数），然后加上冒号，后面跟着格式化符号，在大括号内不应该有任何的空格。

message = 'THe price of this {0:s} laptop is {1:d} USD and 
 the exchange rate is {2:4.2f} USD to 1 EUR'.format('Apple',1299,1.234552 )

print(message)
# THe price of this Apple laptop is 1299 USD and the exchange rate is 1.23 USD to 1 EUR

{0:s}是表示用位置为0的变量来替换，它是字符串格式；{1:d}是用第二个变量替换，它是一个整数类型。

{2:4.2f}表示位置2的变量，是一个浮点类型，总长度为4，其中有两位小数点(格式为4.2f)。

如果不想格式化字符串，大括号里面可以为空，解释器会根据大括号内所提供的变量顺序来替换。

3.4 Python中的类型转换

在Python中有三个内建的函数可以进行类型转换，分别是int()、float()、str()。

int()：将一个浮点型或者字符串转换为整形，如int(5.75343)、int("4")，但不能是int('hello')、int('4.223')等

float()：接收整型或者字符串并转换为浮点型。

str()：将整型或者浮点型转换为字符串。

3.5 列表

表示相关数据的集合，listName = [initial values] ，列表声明是使用中括号[]。

userAge = [21, 23, 24, 27, 25]

1、若不使用任何初始值来声明一个列表，仅需要写listName = []。

2、append()往列表的结尾添加元素。

3、使用索引来访问列表的某个值，索引从0开始，最后一个元素从-1开始。例如userAge[0] = 21。

4、切片如2:4，指的是索引从2到4-1的切片，userAge[2:4] = [24, 27]

5、切片的第三个数字表示步长，userAge[1:5:2] = [23, 27]

6、修改列表，userAge[1] = 5, 列表就会变为userAge = [21, 5, 24, 27, 25]

7、删除， del userAge[2]，列表就会变成userAge = [21, 5, 27, 25]，第三个元素被删除了。

8、extent()连接两个列表，将两个列表的元素拼成一个列表。与append()不同，append会把第二个列表当成一个列表元素加到第一个列表中。

>>> myList = ['a', 'b', 'c']
>>> myList1 = [1, 2, 3]
>>> myList.extend(myList1)
>>> print(myList)
['a', 'b', 'c', 1, 2, 3]
>>> myList2 = ['a', 'b', 'c']
>>> myList2.append(myList1)
>>> print(myList2)
['a', 'b', 'c', [1, 2, 3]]

9、in：检查列表中是否存在某个元素，例如'c' in myList。

10、insert()：在列表中的特定位置添加元素。例如myList.insert(1, 'Hi')，在索引位置1的地方添加字符串'Hi'。

11、len()：得到列表中元素的个数。

12、pop()：得到列表中的一个元素，并把他删除，需要索引位置作为参数，默认为最后一个位置。

13、remove()：从列表中移除一个元素。myList.remove('c')从列表中移除'c'元素

14、reverse()：逆序

15、sort()：以字母顺序或者数字顺序来排列

16、sorted()：返回一个新的排序后的列表，而不排序原来的列表。

17、'+'连接列表。不会修改原列表。

18、'*'复制列表。不会修改原列表。

3.6 元组

元组和列表很像，但是元组的值无法修改。使用圆括号()来声明，tupleName = (初始值)。它的初始值在后面的程序中将保持不变。

例如保持一年中各月份的名字：

monthOfYear = ("Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec")

其索引访问和列表一样。

1、del myTuple：删除整个元组

2、in:检查是否存在某个元素

3、len()：元组的长度

4、'+'和'*'：连接和复制元组，并不会修改元组。

3.7 字典

字典是相关数据对的一个集合，字典的关键字必须是唯一的，可以按照如下声明:dictionaryName = {key:data}，也可以使用dict()函数定义。

>>> userNameAndAge = {"Peter":38, "John":51, 
...                   "Alex":13, "Alvin":"Not Available"}
>>> userNameAndAge
{'Peter': 38, 'John': 51, 'Alex': 13, 'Alvin': 'Not Available'}
>>> userNameAndAge1 = dict(Peter = 38, John = 51,
...                        Alex = 13, Alvin = "Not Available")
>>> userNameAndAge1
{'Peter': 38, 'John': 51, 'Alex': 13, 'Alvin': 'Not Available'}

1、声明一个空字段，dictionaryName={}。

2、添加元素，dictionaryName[dictionary key]=data。

3、删除元素，del dictionaryName[dictionayr key]。

>>> #声明字段，字段的关键字和值可以是不同的数据类型
>>> myDict = {"One":1.35, 2.5:"Two Point Five", 3:"+", 7.9:2}
>>> #打印整个字典，字典的元素的顺序与声明的顺序是不一样的
>>> #打印关键字为"One"的元素
>>> print(myDict["One"])
1.35
>>> #修改关键字2.5的元素
>>> myDict[2.5] = "Two and a Half"
>>> print(myDict)
{'One': 1.35, 2.5: 'Two and a Half', 3: '+', 7.9: 2}
>>> #添加新的元素
>>> myDict["New item"] = "I'm new"
>>> print(myDict)
{'One': 1.35, 2.5: 'Two and a Half', 3: '+', 7.9: 2, 'New item': "I'm new"}
>>> #删除关键字是"One"的元素
>>> del myDict["One"]
>>> print(myDict)
{2.5: 'Two and a Half', 3: '+', 7.9: 2, 'New item': "I'm new"}

4、clear()：移除字典中的所有元素，并返回一个空的字典。

>>> dic1 = {1:'one', 2:'two'}
>>> dic1
{1: 'one', 2: 'two'}
>>> dic1.clear()
>>> dic1
{}

5、del：删除整个字典。

>>> del dic1
>>> print(dic1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'dic1' is not defined

6、get()：返回给定关键字的值，如果没有找到关键字，则返回None，或者指定返回的值。

>>> dic1 = {1:'one', 2:'two'}
>>> dic1.get(1)
'one'
>>> dic1.get(5)
>>> dic1.get(5, "Not Found")
'Not Found'

7、in：检查字典中是否存在一个元素。

>>> dic1 = {1:'one', 2:'two'}
>>> # 基于关键字 
>>> 1 in dic1
True
>>> 3 in dic1
False
>>> # 基于值
>>> 'one' in dic1.values()
True
>>> 'three' in dic1.values()
False

8、items()：以元组的形式返回字典对的列表

>>> dic1 = {1:'one', 2:'two'}
>>> dic1.items()
dict_items([(1, 'one'), (2, 'two')])

9、keys()：返回字典关键字的列表。

>>> dic1.keys()
dict_keys([1, 2])

10、len()：得到字典中元素的总数，如len(dic1)。

11、update()：将一个字典中的关键字-值对添加到另一个字典中，重复的将会被移除。

>>> dic1 = {1:'one', 2:'two'}
>>> dic2 = {1:'one', 3:'three'}
>>> dic1.update(dic2)
>>> print(dic1)
{1: 'one', 2: 'two', 3: 'three'}
>>> print(dic2)  # 没有变化
{1: 'one', 3: 'three'}

12、values()：返回字典中值的列表。

>>> dic1 = {1:'one', 2:'two'}
>>> dic1.values()
dict_values(['one', 'two'])

4、程序可交互

1 input()

使用input()在屏幕上显示提示信息，并提示用户输入相关的信息。

>>> myName = input("Please enter your name:")
Please enter your name:Lily
>>> print(myName)
Lily

2 print()

print()函数用于给用户展示信息，可以传入格式化的字符串%和format()两种形式。

3 转义符号""

 碰到一些特殊的字符而无法打印，比如制表符或者新行等，可以使用""来转义字符，如制表符" "，换行符" "，如果没有斜杠，则会打印出字母t和n。

 5、条件语句

5.1 条件语句

常用的比较符：==、!=、<、>、<=、>=。

逻辑运算符：and、or、not。

5.2 if语句

if conditon 1 is met:
    do A
elif condition 2 is met:
    do B
else:
    do C

5.3 内联if

if语句的一种更简单的形式：

do Task A if conditon is true else do Task B

>>> myInt = 10
>>> num1 = 12 if myInt == 10 else 13
>>> print(num1)
12

5.4 for循环

for a in iterable:
    print(a)

也可以列出成员的索引值，可以使用enumerate()函数。

for index, myPets in enumerate():
    print(index, myPets)

5.5 range()

在一段数字上循环：range(start, end,step)，如果没有start，则以0开始。step没有指定的话，则step=1。

比如range(5)将会发生列表[1, 2, 3, 4, 5]；range(4, 10, 2)会生成列表[4, 6, 8]。

5.6 while循环

如果条件为真的话，则一直循环。

while condition is true:
    do A

5.7 break中断

当循环满足某个条件，则使用break退出循环。

>>> j = 0
>>> for i in range(5):
...     j = j + 2
...     print('i = ', i, 'j = ', j)
...     if j == 6:
...         break
... 
i =  0 j =  2
i =  1 j =  4
i =  2 j =  6

5.8 continue

当满足条件时，continue之后的语句都不会执行，会继续下一个循环。

>>> j = 0
>>> for i in range(5):
...     j = j + 2
...     print('i = ', i, ', j = ', j)
...     if j == 6:
...         continue
...     print('I will be skipped over if j = 6')
... 
i =  0 , j =  2
I will be skipped over if j = 6
i =  1 , j =  4
I will be skipped over if j = 6
i =  2 , j =  6
i =  3 , j =  8
I will be skipped over if j = 6
i =  4 , j =  10
I will be skipped over if j = 6

当j=6时，continue关键字后的那一行将不会打印。

5.9 Try，Except

在错误发生时，可以控制程序执行的方式。

try:
    do somethind
except:
    when an error occurs

可以在except关键字后制定错误的类型。

IOError：IO相关的原因失败

ImportError：寻找模块失败时

IndexError：索引超出范围

KeyError：无法找到关键字

NameError：无法找到局部或者全局的变量

TypeError：类型不匹配

6、函数和模块

6.1 函数定义

def functionName(parameters):
    code detailing
    return [expression]

关键字def和return。一个函数中可以有不止一个return，但是一旦执行了return函数就结束了。可以写return或者return None。

下例是一个判断是否有素数：

>>> def checkIfPrime(numberToCheck):
...     for x in range(2, numberToCheck):
...         if (numberToCheck % x == 0):
...             return False
...     return True
... 
>>> checkIfPrime(13)
True

6.2 变量作用域

局部变量：在函数内定义且只能在函数内访问。

全局变量：在函数外定义且可以在程序中的任何位置访问。

6.3 模块

 1、引入模块

import modulename：把整个模块都引入到程序中。例如import random as r

from modulename import name1[, name2[, ...nameN]]，例如fjrom random import randrange.

2、创建模块

把文件以.py的扩展名保存，并放在想要引入的同一个文件夹里面。比如将以下的代码保存为prime.py

def checkIfPrime(numberToCheck):
    for x in range(2, numberToCheck):
        if (numberToCheck % x == 0):
            return False
    return True

然后在python的终端中输入以下的代码，就可以调用prime.py模块了

>>> import prime
>>> answer = prime.checkIfPrime(13)
>>> print(answer)
True

7、处理文件

7.1 打开文件

open()函数为打开文件，它需要两个参数，第一个是文件的路径，第二个是模式。

目前的模式有：

1、r模式：只读

2、w模式：只写。若文件不存在，则创建；若文件存在，则已有的内容会被删除

3、a模式：添加。若文件不存在，则创建；若文件存在，则写入的内容会追加到文件末尾。

4、r+模式：读写。

5、rb模式和wb模式：用于处理二进制文件（包含非文字的文件），比如图形或者视频等。

7.2 读文件

>>> f = open('prime.py', 'r')
>>> firstline = f.readline()
>>> secondline = f.readline()
>>> print(firstline)
def checkIfPrime(numberToCheck):
>>> print(secondline)
    for x in range(2, numberToCheck):
>>> f.close()

每次调用readline()函数，它都会从文件中读取一行，调用了两次，则会读取两行。

使用for循环读取文本文件：

f = open('file.txt', 'r')
for line in f:
    pirnt(line, end = '')

7.3 写入文件

f = open('file.txt', 'a')
f.write('
This sentence will be appended.')
f.close()

7.4 通过缓冲大小打开并读取文件

通过缓冲大小来读取文件，这样程序就不用使用太多的内存资源。

inputFile = open('myfile.txt', 'r')
outputFile = open('outputfile.txt', 'w')

msg = inputFile.read(10)

while len(msg):  # 只要长度不为0，循环就会继续。直到读完文件。
    outputFile.write(msg)
    msg = inputFile.read(10)  # 写入之后，继续读入下10位的数据

inputFile.close()
outputFile.close()

7.5 删除和重命名文件

remove()：删除一个文件，例如remove('myfile.txt')。

rename()：重命名一个文件，rename('oldfile.txt', 'newfile.txt')

参考：

1、《爱上Python--一日精通Python编程》，Jamie Chan ，新加坡