Python杂货铺速学python基础

“人生苦短，我学 python”是编程届的名言。用 python 写小脚本的便捷性，让很多其他语言的学习者把 python 当作辅助语言。拥有了某一个语言的功底，再来学习另外一种语言应该是十分快速的。编程理念都十分相似，只是看看语言的差异性。带着 Java 的基础，学习 Python，准备上路了。

基础的运算

安装好 python 环境后，运行 win+R，输入 python 直接进入 python 的交互页面，这边可以进行数学运算。

>>> 2+2
4

表 1 数学操作符，优先级从高到低

操作符	操作	例子	值
**	指数	2 ** 3	8
%	取模 / 取余数	22 % 8	6
//	整除 / 商数取整	22 // 8	2
/	除法	22 / 8	2.75
*	乘法	3 * 5	15
–	减法	5 – 2	3
+	加法	2 + 2	4

由上面可以看出 python 前两个基础类型 <mark> 整数 </mark>、<mark> 浮点类型 </mark>。这两个和 java 中的概念差不多。

字符串

作为基础的类型，当然少不了字符串了，和 java 一样，字符串可以进行拼接操作。例如:

>>> 'AAA' + 'BBB'
'AAABBB'
>>> 'CCC'+25
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can only concatenate str (not "int") to str
>>> 'DEF'*3
'DEFDEFDEF'

如上，‘AAA’+’BBB’ 可以直接进行字符串的拼接。但是与 java 不同的是 python 不会进行类型强制转化，所以当用字符串‘CCC’+int 型的 25 的时候就会报错。对 python 进行 * 操作，字符串会进行复制。

变量名

这边插一段，在 java 中进行变量声明的时候，需要指定变量类型，在 python 中不需要，但是 python 变量名也需要一定的规则。

1. 只能是一个词。
2. 只能包含字母、数字和下划线。
3. 不能以数字开头。

类型转化

为了让 int 型的 5 可以转化成字符串类型，从而和字符串拼接，python 提供了一些内置函数。
表 2 一些 python 内置函数
| 函数 | 作用 | 示例 |
| :—–:| :—-: | :—-: |
|str() | 转化类型为字符串 |str(5)|
|int()| 转化类型为整数 |int(‘5’)|
|float()| 转化类型为浮点数 |float(‘5’)|
|print()| 打印函数 | 略 |
|input()| 读取用户输入数据 |myName = input()|
|len()| 内容长度 |len(myName)|

控制流

布尔值

现在引入第四个数据类型，布尔值。python 的布尔值也是有真或者假，但是 python 中的真为 True（注意 T 必须大写），假为 False（F 也必须为大写），同样的布尔类型不能与其他类型相比较。

>>> True
True
>>> true
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'true' is not defined
>>> True = 1
  File "<stdin>", line 1
SyntaxError: can't assign to keyword

比较类型

表 3 比较类型

操作符	含义
==	等于
!=	不等于
<	小于
>	大于
<=	小于等于
>=	大于等于

同时 python 也可以使用二元操作符 <mark>and</mark>、<mark>or</mark>、<mark>not</mark> 同 java 中的与、或、非。

条件与代码块

你前面看到的布尔表达式可以看成是条件，它和表达式是一回事。“条件”只是在
控制流语句的上下文中更具体的名称。条件总是求值为一个布尔值，True 或 False。控制
流语句根据条件是 True 还是 False，来决定做什么。几乎所有的控制流语句都使用条件。

代码块

python 没有 java 中那种 {} 来区分代码块，python 中所有的代码块都是通过缩进进行的。

1. 缩进增加时，代码块开始。
2. 代码块可以包含其他代码块。
3. 缩进减少为零，或减少为外面包围代码块的缩进，代码块就结束了。

>>> if 'a'=='b':
...     print('真')
... else:
...     print('假')
...
假

以上是一个 if else 的控制流，条件后面加上冒号，并且代码块需要缩进方式。

while 循环的格式如下：

spam = 0
while spam < 5:
print('Hello, world.')
spam = spam + 1

另外 python 也有 break 和 continue 关键字可以使用。

for 循环

for 循环单另儿拿出来以示尊重，for 循环的格式如下：

for 关键字；
一个变量名；
in 关键字；
调用 range()方法，最多传入 3 个参数；
冒号；
从下一行开始，缩退的代码块（称为 for 子句）。

for i in range(5):
    print('Jimmy Five Times (' + str(i) + ')')

i 分别执行 0、1、2、3、4.

<mark>range()</mark> 方法其实有三个参数，只是可以省略其中两个。range（start、end、gap），可以指定开始、结束和步长。

>>> for i in range(0,10,3):
...     print(i)
...
0
3
6
9

函数

导入模块

Python 程序可以调用一组基本的函数，这称为“内建函数”，包括你见到过的 print()、input()和 len()函数。Python 也包括一组模块，称为“标准库”。每个模块都是一个 Python 程序，包含一组相关的函数，可以嵌入你的程序之中。例如，math 模块有数学运算相关的函数，random 模块有随机数相关的函数，等等。
利用 <mark>import</mark> 或者 <mark>from import</mark> 语句

自定义函数

除了内建函数，大部分的函数都是自定义的。（即使从模块中导入的函数也是别人自定义好的，让你使用的）

def hello(name):
 print('Hello' + name)

def 函数名(参数)：
    函数体

None

在 Python 中有一个值称为 None, 它表示没有值。None 是 NoneType 数据类型的唯一值（其他编程语言可能称这个值为 null、nil 或 undefined）。就像布尔值 True 和 False 一样，None 必须大写首字母 N。

异常处理

def temp_convert(var):
    try:
        return int(var)
    except ValueError, Argument:
        print "参数没有包含数字 \n", Argument

类似于 java，python 捕获处理一场用的是 try，except，只不过在 except 后面除了可以跟异常类（比如例子中的 ValueError），还可以跟上引发一场的参数（比如例子中的 Argument，其实就是 try 中的 var）

列表

列表可以看作 java 中的数组集合，可以存放一些元素，比如 <mark>>>> spam = [‘cat’, ‘bat’, ‘rat’, ‘elephant’]</mark>。我们可以通过 index 获取某个元素，比如 spam[0]=‘cat’，同时可以从后往前拿数据，比如 spam[-1]=’elephant’。

切片

除了直接操作 index，获取某个元素之外，还可以通过切片获得一段子列表。

>>> spam[1:3]
['bat', 'rat']
>>> spam[0:-1]
['cat', 'bat', 'rat']

列表的拼接与复制

与 java 不同的是，python 的列表可以自由的拼接复制。

>>> [1, 2, 3] + ['A', 'B', 'C']
[1, 2, 3, 'A', 'B', 'C']
>>> ['X', 'Y', 'Z'] * 3
['X', 'Y', 'Z', 'X', 'Y', 'Z', 'X', 'Y', 'Z']

列表结合某些关键字和方法

1. 删除某列表中的某元素，可以直接用 del 关键字。
2. 也可以结合 for 循环

>>> supplies = ['pens', 'staplers', 'flame-throwers', 'binders']
>>> for i in range(len(supplies)):
print('Index' + str(i) + 'in supplies is:' + supplies[i])

1. 利用 in、not in 直接判断某元素是否在列表中

>>> 'howdy' in ['hello', 'hi', 'howdy', 'heyas']
True
>>> spam = ['hello', 'hi', 'howdy', 'heyas']
>>> 'cat' in spam
False

1. index()方法判断某元素在列表中的第一次出现的下标，没有的话就报错。

>>> spam = ['Zophie', 'Pooka', 'Fat-tail', 'Pooka']
>>> spam.index('Pooka')
1

1. 用 append()和 insert()方法在列表中添加值

append()方法调用，将参数添加到列表末尾。insert()方法可以在列表任意下标处插入一个值。insert()方法的第一个参数是新值的下标，第二个参数是要插入的新值。

1. 用 remove()方法从列表中删除值
2. 用 sort()方法将列表中的值排序

元组

在 java 中，我们知道 String 是被 final 修饰的，所以 String 本身是不能修改的，如果对 String 进行修改，其实是在内存中新建了一个新的 String。类似的 python 中也有一个不可修改的数据类型——元组。元组和列表差不多，很多方法都是共通的。只不过，元组是用 ”()” 表示，并且元组内的元素不能被修改，也不能对元组进行增加删除操作。

元组和列表的转化

函数 list()和 tuple()将返回传递给它们的值的列表和元组版本。

>>> tuple(['cat', 'dog', 5])
('cat', 'dog', 5)
>>> list(('cat', 'dog', 5))
['cat', 'dog', 5]
>>> list('hello')
['h', 'e', 'l', 'l', 'o']

引用与引用函数

>>> spam = [0, 1, 2, 3, 4, 5]
>>> cheese = spam
>>> cheese[1] = 'Hello!'
>>> spam
[0, 'Hello!', 2, 3, 4, 5]
>>> cheese
[0, 'Hello!', 2, 3, 4, 5]

看上面的代码，非常好理解，spam 将引用复制给 cheese，而不是复制的对象，所以对某个引用操作，都会改变那唯一的对象。如果想为 cheese 引用生成一个新的对象，就需要用到拷贝函数 copy()和 deepcopy()。其实就是 java 中的浅拷贝和深拷贝。

>>> import copy
>>> spam = ['A', 'B', 'C', 'D']
>>> cheese = copy.copy(spam)
>>> cheese[1] = 42
>>> spam
['A', 'B', 'C', 'D']
>>> cheese
['A', 42, 'C', 'D']

deepcopy()深拷贝是指，不仅生成一个与 spam 一样新的对象，连 spam 内部的数据也一起复制一堆新的对象出来。就好比说把 ’A’,’B’ 这种元素分别换成一个个子列表，浅拷贝不会对他们复制，而深拷贝会对这些对象进行复制。

字典

像列表一样，“字典”是许多值的集合。但不像列表的下标，字典的索引可以使用许多不同数据类型，不只是整数。字典的索引被称为“键”，键及其关联的值称为“键 - 值”对。所以可以说字典就是 java 中的 Map。

 myCat = {'size': 'fat', 'color': 'gray', 'disposition': 'loud'}

与列表不同的是，字典没有顺序的概念，所以不能通过操作 index 获取某元素，不能使用切片，不能使用排序函数。

操作字典

基本操作

所以操作字典，就需要另辟蹊径，使用函数 keys()、values()和 items()。顾名思义，分别是获取字典的 key 值们，val 值们，和键值对本身们。

>>> spam = {'color': 'red', 'age': 42}
>>> for v in spam.values():
        print(v)
red
42
>>> for k in spam.keys():
        print(k)
color
age
>>> for i in spam.items():
        print(i)
('color', 'red')
('age', 42)

值得一提的是 spam.keys()获得的是元组，如果希望的到对应的列表就需要用 list 函数转化。

检查字典中是否存在键或值

可以利用 in 或者 not in 关键字判断数据是否在字典中。

>>> spam = {'name': 'Zophie', 'age': 7}
>>> 'name' in spam.keys()
True
>>> 'Zophie' in spam.values()
True
>>> 'color' in spam.keys()
False
>>> 'color' not in spam.keys()
True
>>> 'color' in spam
False

get()和 setdefault()方法

get()可以通过 key 值找到相对应的 value 值。get 有两个参数，第一个参数是 key 值，第二个参数是在键值对不存在 (或者说 key 不存在) 的时候，给予的默认值。

>>> picnicItems = {'apples': 5, 'cups': 2}
>>> 'I am bringing' + str(picnicItems.get('cups', 0)) + 'cups.'
'I am bringing 2 cups.'
>>> 'I am bringing' + str(picnicItems.get('eggs', 0)) + 'eggs.'
'I am bringing 0 eggs.'

setdefault()有两个参数，第一个是要插入键值对的 key 值，第二个是默认值。当原字典中有这个 key 值，就什么也不做，如果原字典中没有这个 key 值，就将默认值作为 value，同 key 一起拼成键值对插入到字典中。

>>> spam = {'name': 'Pooka', 'age': 5}
>>> spam.setdefault('color', 'black')
'black'
>>> spam
{'color': 'black', 'age': 5, 'name': 'Pooka'}
>>> spam.setdefault('color', 'white')
'black'
>>> spam
{'color': 'black', 'age': 5, 'name': 'Pooka'}

字符串操作

我们早已经知道了字符串和其基本操作了，当我们又学习了列表、元组、字典之后再来看一下更加丰富的处理字符串的方法。

转移字符和原始字符

和 java 一样，python 也是用 对特殊字符进行转义。同时，还有原始字符 r。可以在字符串开始的引号之前加上 r，使它成为原始字符串。“原始字符串”完全忽略所有的转义字符，打印出字符串中所有的倒斜杠。

>>> print(r'That is Carol\'s cat.')
That is Carol\'s cat.

注释与多行字符

python 单行注释可以使用特殊字符 #，同时多行注释可以使用 ”””.

# 这是一行注释
"""
这是多行注释
这是多行注释
这是多行注释
"""

有时候我们在使用 print 函数的时候，打印的字符串很长很长，为了页面好看，可以使用 ”’ 将大字符串拆分成好几行。

print('''Dear Alice,
Eve's cat has been arrested for catnapping, cat burglary, and extortion.
Sincerely,
Bob''')

字符串下标和切片

一个字符串也可以当作列表来处理，其中元素可以看作是一个个字符。所以就可以对字符串进行下标操作或者切片操作。同样的就可以利用 in、not in 判断某字符是否在字符串内了。

>>> spam = 'Hello world!'
>>> spam[0]
'H'
>>> spam[4]
'o'
>>> spam[-1]
'!'
>>> spam[0:5]
'Hello'
>>> spam[:5]
'Hello'
>>> spam[6:]
'world!'

一些字符串内建方法

1. upper() 字符串全部变大写
2. lower() 字符串全部变小写
3. isupper()字符串至少有一个字母，并且所有字母都是大写
4. islower()字符串至少有一个字母，并且所有字母都是小写
5. isalpha()字符串只包含字母，并且非空
6. isalnum()字符串只包含字母和数字，并且非空
7. isdecimal()字符串只包含数字字符，并且非空
8. isspace()字符串只包含空格、制表符和换行，并且非空
9. startswith()字符串以该方法传入的字符串开始
10. endswith()字符串以该方法传入的字符串结束
11. join()拼接字符串，可指定分隔符
12. split()通过某值切割字符串
13. rjust()左填充，如果输出数据不足，补充空格
14. ljust()右填充，如果输出数据不足，补充空格
15. center()字符串居中，左右数据不足，补充空格

结束

呜呼，python 的基础语法就算过了一遍，当然这只是基础中的基础。像 python 怎么处理多线程、类的概念、内存管理等内容有时间再看吧。不忘初心，最开始学习 python 只是把它当作辅助语言，写写小脚本什么的，不打算研究太深，毕竟时间有限，java 还有很多东西要去研究，并且，除了编程，这个世界还有很多美好的事情等待我去体验。学以致用，写爬虫也是我学习 python 的一个动力，写了一个小脚本爬取豆瓣电影 TOP250.（好像这个是爬虫入门经典案例吧，哈哈）代码贴一下

import requests as rq
from bs4 import BeautifulSoup
import pandas as pd

def get_data(url):
    print(url)
    html = rq.get(url).content.decode("utf-8")
    soup = BeautifulSoup(html,"lxml")
    divItems = soup.find_all("div","item")

    for item in divItems:
        name = item.find('span',{'class':'title'}).text
        rating_num = item.find('span',{'class':'rating_num'}).text
        number = item.find('em').text
        imgUrl = item.find("img").attrs['src']
        print("----------->")
        print("number:"+number)
        numbers.append(number)

        print("name:"+name)
        names.append(name)

        print("rating_num:"+rating_num)
        rating_nums.append(rating_num)

        print("imgUrl:"+imgUrl)
        imgUrls.append(imgUrl)
        print("----------->")


data_df = pd.DataFrame()
numbers = []
names = []
rating_nums = []
imgUrls = []

for num in range(0,10):
    get_data("https://movie.douban.com/top250?start={}&filter=".format(int(num)*25))

data_df["序列"] = numbers
data_df["名称"] = names
data_df["评分"] = rating_nums
data_df["海报"] = imgUrls
writer = pd.ExcelWriter('movie_top250.xlsx')
data_df.to_excel(writer, 'page_1', float_format='%.5f')  # float_format 控制精度
writer.save()

当然，提前需要 install 的模块
requests
BeautifulSoup4
pandas
openpyxl
lxml(BeautifulSoup4 的解析器)

结束。