Python 学习 01 —— Python基础

---

系列文章

Python 学习 01 —— Python基础
Python 库学习 —— urllib 学习
Python 库学习 —— BeautifulSoup4学习
Python 库学习 —— Re 正则表达式
Python 库学习 —— Excel存储（xlwt、xlrd）
Python 学习 02 —— Python爬虫
Python 库学习 —— Flask 基础学习
Python 学习03 —— 爬虫网站项目

---

一、Python基础

1、简单介绍

1. Python 是一门解释型、面向对象的高级编程语言。（解释型：运行前无需生成中间代码，面向对象：封装、继承、多动态）

2. Python的设计混合了传统语言的软件工程的特点和脚本语言的易用性，具有如下特性：

   • 开源、易于维护

   • 可移植

   • 易于使用、简单优雅

   • 广泛的标准库、功能强大

   • 可扩展 、可嵌入（在单片机上也可以用Python）

3. Python缺点：

   • 运行速度慢：由于Python是解释型语言，运行时翻译为机械码非常耗时，但像C语言是运行前直接编译成CPU能执行的机械码。不过大量应用程序并不需要这么快的运行速度，因为用户一般也感觉不出性能差别。（企业针对大型项目有性能需求）
   • 代码无法加密：由于解释型语言发布程序就是发布源代码，其他用户可以直接看到，而像C语言这种编译型语言是把编译后的机械码发出去，机械码无法反推出源码。

4. Python应用：

2、环境搭建

Python环境比较简单，无论是Mac还是Windows都直接去官网下载最新版安装就行，然后再装一个IDE（通常是PyCharm）

• python官网：www.python.org , Windows安装，记得勾选下面选项。

  

  安装完成后，在命令行下输入python，看是否能成功运行。

  

  如果不能，可能是环境变量问题，去检查系统变量PATH里是否包括下面两个变量。

  

  如果环境变量正确，输入命令行python却打开了Windows应用商店，则删除下面PATH的变量（环境变量是从上到下的优先级，把Python的路径调到商店前面也可以）

  

  在MacBook上，运行是输入 python3，因为MacBook自带了python2，所以我们输入python是默认使用的2.0。

• Pycharm官网：https://www.jetbrains.com/zh-cn/pycharm/

  安装时下面的全部勾选。

  

  进入PyCharm创建新项目，这里选第一个，用于创建纯Python的项目。

  

  进入后建议先进行一些常规设置，例如代码的字体、项目格式模板。（Windows快捷键：Ctrl+Alt+S，Mac快捷键：command+，）

  

3、基本知识

注释

# 单行注释

'''
多行注释
'''

变量

• 变量可以是任意的数据类型（浮点数、整型、字符串……）
• 变量名不能以数字开头，可以是字母、数字、下划线的组合
• 给变量赋值：例如a="abc"，此时Python解释器做了两件事，在内存中创建了“abc"的字符串，然后又在内存中创建了名为a的变量，并让变量a指向”abc“。

输出

# 普通输出
print("这是一个普通输出")

# 格式化输出 %s 字符串占位符，%d整型占位符，
a = 123
b = "这是格式化输出"
print("这是格式化输出%d" % a)  # 一个占位符
print("%s，%d" % (b, a))  # 多个占位符

# 如果直接用逗号隔开
print("aaa", "bbb", "ccc")
# 设置分隔符
print("www", "baidu", "com", sep=".")
# 设置结束符
print("hello", end="")  # 设置结束符为空，默认是换行
print("world", end="\t")  # 设置结束符为TAB
print("python", end="\n")  # 设置结束符为换行
print("end")

输入

使用input()方法来获取输入，需要注意的是这种方式获取到的都是字符串类型。

#  输入
password = input("请输入密码：")
print("您输入的密码是：", password)

# 查看变量类型
print(type(password))

# 强制转换
b = int(password)
print("b的类型：", type(b))

引入库

在Python中使用import或from xx import导入相应模块。

• import是导入整个模块。
• from aa import bb是从aa模块中导入bb函数。
• from aa import bb, cc是从aa模块导入bb、cc函数。
• from aa import \*是从aa模块导入全部函数。

import random  # 导入随机库
x = random.randint(0, 2)  # 获取一个0-2的整数

4、判断与循环

1. if判断

   格式如下，需要注意的是，Python的代码块是依靠缩进完成的，通常内部代码前面会用TAB键来缩进。

   同时，Python的判断表达式可以是True和False，也可以是0和非0。Python中else if的写法是elif。

   # True 可以用1，-1等非0值表示。
   if True:
       print("True")
   else:
       print("False")
   
   score = input("请输入分数：")
   score = int(score)
   # 逻辑运算进行判断 and or not，或者直接连续用符号判断
   if 90 <= score <= 100:
       print("优秀")
   elif score >= 60 and score < 80:
       print("合格")
   else:
       print("不合格")
   

2. for循环

   # for循环1 从0开始，到5结束
   for i in range(5):
       print(i)
   # for循环2 从0开始，到11结束，每次增加3
   for i in range(0, 11, 3):
       print(i, sep=",")
   # for循环3 从-10开始，到-100结束，每次增加（-30）
   for i in range(-10, -100, -30):
       print(i, sep=",")
   # for循环4 遍历字符串
   name = "chongqing"
   for x in name:
       print(x, end="\t")
   # for循环5 遍历列表
   a = ["aa", "bb", "cc"]
   for x in range(len(a)):
       print(x, a[x])
   

3. while循环

#  while循环1
i = 0
while i < 5:
    print("第%d次循环" % (i + 1))
    print("i=%d" % i)
    i += 1

# while循环2  当while结束时，会进入else里
count = 0
while i < 5:
    print(count, "小于5")
    count += 1
else:
    print(count, "大于或等于5")

在循环中，break和continue是同样的作用，break结束循环，continue开始下一次循环。同时，有关键字pass，用于占位，没有其他意义。

5、字符串、列表、元祖、字典

字符串

• Python的字符串可以用单引号、双引号、三引号括起来，可以使用反斜杠\来转义特殊字符

  # 单双引号本身没什么区别，不过有特殊用法，例如下面这样
  a = "I'm a student."
  
  # 转义字符 \
  b = "Bob said \"I love you\"."
  b2 = 'Bob said "I love you."' 
  
  # 三引号可以保留换行的格式
  c = """
  	1
  	2
  	3
  """
  

• Python3默认以UTF-8编码，所有字符串都是unicode字符串

• 可以对字符串进行拼接、截取

  # 字符串拼接
  a = "Hello"
  b = "Python"
  print("a+b 的结果：", a + b)  # a+b 的结果： HelloPython
  print("你好，"+b)  # 你好，Python，与上面的区别是这样没有空格（逗号的默认分隔符是空格）
  print(b*3)  # PythonPythonPython，输出三次
  
  # 字符串截断
  print("a[1:4]输出结果：", a[1:4])  # a[1:4]输出结果： ell，从下标0输出到下标4
  print("a[1:4:2]输出结果：", a[1:4:2])  # a[1:4:2]输出结果： el，每次加2（步进值2）
  print("a[1:]输出结果：", a[1:])  # a[1:]输出结果： ello，从下标1开始输出到最后
  print("a[:1]输出结果：", a[:1])  # a[:1]输出结果： H，从开始输出到下标1（不包括下标1）
  

• 特别注意：关于转义

  # 如果在字符串前面加r，这该字符串的所有转义都失效，后面爬虫会经常用到这点，为了使链接的\失去转义功能，获取正常链接
  print(r"Hello\nPython")  # 输出：Hello\nPython
  

• 字符串常用函数

  使用	描述
  isalnum()	若字符串至少有一个字符且所有字符都是字母或数字，则返回True
  isalpha()	若字符串至少有一个字符且所有字符都是字母，则返回True
  isdigit()	若字符串只包含函数字则返回True
  isnumeric()	若字符串只包含数字字符则返回True
  join(seq)	以当前字符串为分隔符，把seq中的所有元素合并为一个新字符串
  len(string)	返回字符串长度
  lstrip()	去掉字符串左边的空格
  rstrip()	去掉字符串右边的空格
  split(str,num,count)	以str为分隔符，分割当前字符串。如果有num则截取num+1个

列表

• Python的列表类似于其他语言的数组，最大的区别是，Python的列表里的类型可以不相同。

  # 使用[]，元素用,隔开
  list = ['abc', 123, 1.1, "ABC"]
  print(list[0], type(list[0]))  # abc 
  print(list[1], type(list[1]))  # 123 
  
  # 列表可以追加和扩展
  

• 列表下标从0开始，-1是末尾位置。（即列表可以倒着遍历）

  # for 遍历列表
  for temp in list:
      print(temp)
  
  # while 遍历列表
  length = len(list)
  i = 0
  while i < length:
      print(list[i])
      i += 1
  

• 列表可以用+操作符进行拼接，使用*进行重复。

• 列表常用操作

操作名称	操作方法	举例
访问列表元素	通过下标直接访问	print(list[0])
列表的切片	使用[1:2:3]	list[1:2:3]
遍历列表	通过for循环	for i in list: print(i)
【增】新增元素到列表尾	append	list.append(5)
【增】列表的追加	extend	list.extend(list2)
【增】列表数据的插入	insert	list.insert(1,3)
【删】列表的删除	del:删除指定下标元素 remove:移除列表指定值的第一个匹配值。若都没有匹配则抛出异常。	del list[0]，list.remove(0)
【删】弹出列表尾部元素	pop	list.pop()
【改】更新列表数据	通过下标修改	list[0] = 1
【查】列表成员关系	in、not in	2 in list
【查】指定元素的 下标	index：从下标1到下标2，找指定元素并返回下标。（不包含下标2）	list.index(元素, 下标1, 下标2)
【查】统计指定元素	count	list.count(x)
列表的加法操作	+	list3 = list1 + list2
【排】列表排序	sort【默认升序，降序是sort(reverse=True)】	list.sort()
【排】列表反转	reverse	list.reverse()

元祖

• 元祖Tuple和列表List类似，区别在于元祖的元素不能被修改。

• 元祖的元素不可变，但可以包含可变的对象，例如List

  # 元祖用小括号
  a = ("abc", 123)
  
  # 只有一个元素也要加逗号【空元祖 就是一个括号 x = ()】
  b = (1, )
  
  # 修改元祖的元素会抛出异常 a[1] = 111
  # 不能删除元祖中某个元素，但可以删除整个元祖 del a
  
  # 两个元祖可以拼接
  t1 = (1, )
  t2 = (2, )
  c = t1+t2 # （1, 2）
  
  # 可以包含可变对象，例如列表，针对列表元素是可以修改的
  d = ("a", [1, 2])
  

字典

• 字典是无序的对象集合，使用键值对存储，具有极快的查找速度。

• 键必须使用不可变类型。

• 在同一个字典中，键必须是唯一的。

  # 字典定义
  info = {"name": "小白", "age": 18}
  
  # 字典访问
  print(info["name"])  # 通过下标访问，若键不存在则报错
  print(info.get("gender"))  # 使用get方法访问，若键不存在则默认返回None
  print(info.get("gender", "man"))  # 使用get方法访问，若键不存在返回man
  

• 字典的增删改查

  # 增
  info["id"] = 123456
  print(info)  # {'name': '小白', 'age': 18, 'id': 123456}
  
  # 删 (删除的是整个键值对，也可以删除整个字典）
  del info["age"]  # {'name': '小白', 'id': 123456}
  info.clear()  # 清空字典  {}
  
  # 改
  info["id"] = 111111
  
  # 查
  # 得到所有的键（返回的是列表）
  print(info.keys())
  for key in info.keys():
      print(key)
  # 得到所有值（返回的是列表）
  print(info.values())
  for value in info.values():
      print(value)
  # 得到每个键值对（返回的是列表，每个元素是一个元祖）
  print(info.items())
  for key, value in info.items():
      print("key=%s，value=%s" % (key, value))
  

  根据字典的查，可以看出，实际上for遍历是可以有多个参数的，因此，前面对列表的遍历可以优化。

  # 使用枚举配合列表，以便同时拿到下标和元素内容。
  # 其中enumerate()是处理枚举。
  a = ["a", "b", "c", "d"]
  for i, x in enumerate(a):
      print(i, x)
  

集合

• 集合set和字典dict类似，也是一组key的集合，但set不存储value。由于key不能重复，因此在set中的内容都是无重复的。

• 集合set是无序的。

  ss = set([1, 1, 2, 3, 3])
  print(s)  # 输出{1, 2, 3}
  

小结

	是否有序	是否可变
列表[ ]	有序	可变
元祖( )	有序	不可变
字典{ }	无序	key不可变，value可变
集合{ }	无序	可变（不重复）

6、函数

• 函数的定义

  # 无参 无返回值
  def 函数名():
    代码
  
  # 有参
  def 函数名(参数1, 参数2):
    代码
  
  # 有返回值
  def 函数名(参数1，参数2):
    return xxx
  

• 举例：返回多个值

  def divid(a, b):
    shang = a//b
    yushu = a%b
    return shang, yushu
  
  s, y = divid(5, 2)
  print(shang, yu)
  

• 全局变量和局部变量问题：

  a = 1 # 这是全局变量
  def test():
    global a # 声明 a是全局变量
    a = 2
    print(a)
   print(a)
  
  # 如果不声明a是全局变量，那么a会作为函数test的局部变量，从而无法影响到外部的a
  

7、文件操作

文件操作和C语言有点像，也是使用open函数，同时有各种模式。

# r 只读方式打开（默认模式）,若文件不存在则抛出异常
# w 写模式，若文件存在则将其内容覆盖，若文件不存在则创建新文件
# a 追加模式，若文件存在不会覆盖，而是追加到后面
# rb、wb，二进制的方式读写文件。

f = open("test.txt", "w")  # 打开文件，此时文件不存在，会创建名为test.txt的文件
f.write("Hello World!")  # 写入字符串
f.close()  # 关闭文件，这样其他程序才能访问该文件

f = open("test.txt", "r")  # 读取文件
content1 = f.read(5)  # 读取5个字符
content2 = f.readline()  # 读取一行
content3 = f.readlines()  # 读取所有行，每行作为一个列表元素

# 使用with open() as 来优化文件操作，这种方式自动捕获异常并调用close()
# 这也是try finally简便版，推荐使用。
with open('test.txt','r') as f :
   print(f.read())

文件常规操作：需要先导入os模块

import os

# 文件重命名
os.rename("test.txt", "test2.txt")
# 删除文件
os.remove("test2.txt")
# 创建文件夹
os.mkdir("临时文件夹")
# 删除文件夹
os.rmdir("临时文件夹")
# 获取当前目录
print(os.getcwd())
# 改变默认目录
os.chdir("../")
# 获取目录列表
os.listdir("./")

8、异常

• 捕获异常

  try:
      print("-----test1-------")
      f = open("123.txt", "r")  # 123.txt文件不存在，所以会抛出 FileNotFound异常
      print("-----test2-------")
      try:
        # pass不做任何事，只表示占位通过
        pass # 假设这里出现问题，但此时文件已经打开
      finally:
  		  f.close() # finally中的代码是一定会执行的，所以只要文件打开了，无论是否异常，必定会关闭
  except IOError:
    	# exception的代码是在捕获到异常后执行
      # 异常捕获类型需要一致，假如把IOError改为NameError就无法捕获
      pass
  
  # except (IOError, NameError):  这种就包含了两种异常
  # except (IOError, NameError) as result: 这种是用result作为对象，可以直接打印result
  # except Exception as result: Exception是所有异常父类，用它来捕获所有异常
  

9、自定义模块

模块：用来从逻辑上组织Python代码（变量、函数、类），本质就是.py文件，用于提高代码的可维护性。（类似Java的包）

1. 创建两个文件夹，再分别创建两个文件，如下所示：

2. 在t1.py中定义一个加法函数，如下所示：

3. 在t2.py中引用自定义的模块，如下所示：