1. python 循环
1.1 while 循环
# while 循环
condition = 1
while condition < 10:
print(condition)
condition = condition + 1
注：在Python中，True 和False 分别表示正确和否定。在循环中，当正确时会继续执行；当否定时则会结束执行。
Python在每一个while或for循环中，都需要在第一行最后结束位置处引一个冒号 : 用来结束
1.2 for 循环
# for 循环
# list ---> 列表
example_list = [1,2,3,4,5,45,67,433,5,66]
for i in example_list:
print(i)
print('inner of for')
print('outer of for')
1.2.1 python内置函数 — 针对于for循环
range 函数 —> Python内置函数，可用于for循环中。一个电脑自动生成的迭代器。
# range函数 实际上是 1~9
for i in range(1,10):
print(i)
range函数 第三个参数为步长
for i in range(1,10,5):
print(i)
1.3 python 循环中的两个重要方法(break & continue)
break：跳出整个循环，不会执行下面的任何语句
continue：跳出本次循环(不会执行continue下面的代码)，继续下一次循环
a = True
while a:
b = input('type something')
if b == '1':
a = False
else:
pass # pass 就是什么都不做
print('finish run')
举例说明 break&continue
# python 循环中的两个重要方法(break & continue)
while True:
b = input('type something')
if b == '1':
break # break 跳出整个循环，不会执行下面的任何语句
else:
pass # pass 就是什么都不做
print('still in while')
print('finish run')
# python 循环中的两个重要方法(break & continue)
while True:
b = input('type something')
if b == '1':
continue # continue 跳出本次循环(不会执行continue下面的代码)，继续下一次循环
else:
pass # pass 就是什么都不做
print('still in while')
print('finish run')
2. python 条件语句
if 语句 —> 当条件成立时 执行
x = 1
y = 2
z = 0
if x<y:
print('x is less than y')
if x<y>z:
print('x is less than y, and y is greater than z')
a = 2
b = 2
if a<=b:
print('a is less or equal to b')
# python中判断相等 ==
c = 6
d = 6
e = 7
if c == d:
print('c is equal to d')
# python中判断不相等 !=
if d!=e:
print('d is not equal to e')
if … else … 语句
注： if 和 else 后都要有 冒号 :
x = 4
y = 2
z = 3
if x>y:
print('x is greater than y')
else:
print('x is less or equal to y')
if … elif … else … 语句
注：只会执行一个
x = -2
if x>1:
print('x > 1')
elif x<-1:
print('x < -1')
elif x<1:
print('x < 1')
else:
print('x = 1')
print('finish running')
3. python 函数 def
def —> define的缩写 无参函数定义形式: def 函数名():
要使用定义好的函数 需要对函数进行函数调用
#python 函数 def
def function():
print('This is a function')
a = 1 + 2
print(a)
# 函数调用
function()
def —> define的缩写 有参函数定义形式: def 函数名(参数1,参数2,…):
def fun(a,b):
c = a*b
print('the c is' , c)
fun(2,5)
# 强调一下将具体某个变量赋值为具体哪一个值
fun(a = 2 , b = 5)
def —> define的缩写 函数默认参数
# 给定函数默认参数 —— 即定义函数时，直接给函数参数赋值
def sale_car(price,color='red',brand='carmy',is_second_hand=True):
print('price:',price,
'color:',color,
'brand:',brand,
'is_second_hand:',is_second_hand)
# sale_car(1000,'red','carmy',True)
# 使用函数默认参数
sale_car(13100)
# 不想使用函数参数的默认值，可以再函数调用时进行参数重新赋值
sale_car(12300,'blue')
补充：函数返回值/输出值 —> return
def fun():
a = 10
print(a)
# 函数返回/输出值
return a + 100
print(fun())
4. python 全局变量&局部变量
全局变量：通常字母都大写 APPLE
# python 全局 & 局部变量
# APPLE 全局变量
APPLE = 100
def fun():
# a 此时为局部变量
a = 10
return a + 100
print(APPLE)
# 报错
print(a)
# python 全局 & 局部变量
# APPLE 全局变量
APPLE = 100
def fun():
# a 此时为局部变量
a = APPLE
return a + 100
print(APPLE)
# 输出 200
print(fun())
使用 global 定义全局变量
# python 全局 & 局部变量
# APPLE 全局变量
APPLE = 100
# 要使用 global 定义全局变量，需将此变量在最开始赋值为 None
a = None
def fun():
# global ---> 将 a 定义成一个全局变量
# 无论怎样 此时 a 都是一个全局变量
global a
a = 20
return a + 100
print(APPLE)
print('a past =', a)
print(fun())
print('a now =', a)
不使用 global 定义全局变量(与 使用 global 定义全局变量进行对比)
APPLE = 100
# 要使用 global 定义全局变量，需将此变量在最开始赋值为 None
a = None
def fun():
# a 为局部变量不能输出到全局
a = 20
return a + 100
print(APPLE)
print('a past =', a)
print(fun())
print('a now =', a)
5. python 外部模块安装
研究型编程大部分会与数学有关联，而数学相关的模块就可能会是NumPy。
参考此文章即可 链接: 如何手动安装 numpy
# 测试 numpy 是否安装成功
from numpy import *
# 输出随机矩阵 即安装成功
print(random.rand(4,4))
6. python文件读写
python中换行符 \n
text = 'This is my first test.\nThis is next line.\nThis is last line.'
print(text)
例1：简单文件的写入
# python 文件读写
text = 'This is my first test.\nThis is next line.\nThis is last line.'
# 以写的形式打开文件
my_file = open('my file.txt','w')
# 在文件里写内容
my_file.write(text)
# 关闭文件
my_file.close()
例2：简单文件的内容追加
# python 文件读写
# 在已有文件的后面进行内容追加
append_text = '\nThis is appended file.'
# 以追加内容的形式打开文件
my_file = open('my file.txt','a')
# 再打开文件的后面追加内容
my_file.write(append_text)
# 关闭文件
my_file.close()
例3：简单文件的读取
# python 文件读写
# 以读的形式打开文件
# 此时是将打开的文件存到 file里 而不是将文件的内容存到file里
file = open('my file.txt','r')
# 读取文件中的内容
content = file.read()
# 输出文件中的内容
print(content)
7. python 类(class)
python中 类(class)一般是以大写字母开头，即首字母大写。后面要有冒号 :
类(class)可能会有自己的属性也可能会有自己的功能。
# python class 类
# 类(class)的定义功能有一点不一样，要在函数中加一个self
class Calculator:
# 类(class)的属性
name = 'Good calculator'
price = 18
# 函数 ---> 类(class)中的功能
def add(self,x,y):
# 调用自己类中的属性 需使用self
print(self.name)
result = x + y
print(result)
def minus(self,x,y):
result = x - y
print(result)
def times(self,x,y):
print(x * y)
def divide(self,x,y):
print(x / y)
7.1 类(class)的初始(init)
类(class)的初始(init) 即在刚开始生成类的时候，要给类初始定义一些信息。
注：init 两边各有两个下划线
# python class 类
# 类(class)的定义功能有一点不一样，要在函数中加一个self
class Calculator:
# 类(class)的属性
name = 'Good calculator'
price = 18
# 类(class)的初始(init)
def __init__(self,name,price,height,width,weight):
self.name = name
self.price = price
self.hei = height
self.wid = width
self.wei = weight
# 函数 ---> 类(class)中的功能
def add(self,x,y):
# 调用自己类中的属性 需使用self
print(self.name)
result = x + y
print(result)
def minus(self,x,y):
result = x - y
print(result)
def times(self,x,y):
print(x * y)
def divide(self,x,y):
print(x / y)
# python class 类
# 类(class)的定义功能有一点不一样，要在函数中加一个self
class Calculator:
# 类(class)的初始(init)
def __init__(self,name,price,height,width,weight):
self.name = name
self.price = price
self.hei = height
self.wid = width
self.wei = weight
# 函数 ---> 类(class)中的功能
def add(self,x,y):
# 调用自己类中的属性 需使用self
print(self.name)
result = x + y
print(result)
def minus(self,x,y):
result = x - y
print(result)
def times(self,x,y):
print(x * y)
def divide(self,x,y):
print(x / y)
8. python 输入(input)
输入(input)：在输出的屏幕中进行数据的输入。
# python input 输入
# 将输入的值赋值给 a_input
# input 的返回值是一个字符串 return a string
a_input = input('Please give a number:')
if a_input == '1':
print('This is a good one')
elif a_input == str(2):
print('See you next time')
else:
print('Good Luck')
9. python 元组和列表
元组和列表比较相似。元组 —> tuple 列表 —> list。
元组和列表都是一连串有顺序的数字
一般来说元组(tuple)是用小括号( )，也可以将小括号( )省略掉 而列表(list)是用中括号[ ]
元组(tuple)和列表(list)的用途：基本上用于迭代一个一个进行输出
注：在元组(tuple)和列表(list)中，索引都是从0开始的
# python 元组和列表
# 元组(tuple) 的定义形式1
a_tuple = (12,3,5,15,6)
# 元组(tuple) 的定义形式2
another_tuple = 2,4,6,7,8
# 列表(list)的定义形式
# a_list[0] ---> 12 a_list[1] ---> 3 .....
a_list = [12,3,67,7,82] # 此时列表长度为 5
# 迭代进行一个一个输出
# 输出列表的值
for content in a_list:
print(content)
print('-----------------------')
# 输出元组的值
for content in a_tuple:
print(content)
# range(5) ---> 依次输出 0~4
for index in range(len(a_list)): # len( ) ---> 计算列表的长度
print('index = ',index,'number in list = ',a_list[index])
print('-----------------------')
for index in range(len(a_tuple)): # len( ) ---> 计算列表的长度
print('index = ',index,'number in tuple = ',a_tuple[index])
9.1 列表(list)常用函数
- 追加数值 append() —> 在列表的最后追加一个值
a = [1,2,3,4,2,3,1,1]
# 在列表(list) a 的最后追加 一个值 0
a.append(0)
print(a)
- 指定位置添加数值 insert()
a = [1,2,3,4,2,3,1,1]
# 指定位置添加数值
# 向第二个位置添加数值 0
a.insert(1,0)
print(a)
- 移除元素 remove()
a = [1,2,3,4,2,3,1,1]
# 移除数值
# 移除的是列表(list)中具体的数值，而不是指数据元素在列表中的索引
# 只会移除列表中第一次出现的数值，后面相同的数值不会移除
a.remove(1)
print(a)
- python中 负索引 -1 的含义
-1 : 代表最后一个元素
a = [1,2,3,4,2,3,1,-1]
# python 中存在 负索引
# 索引 -1 ---> 在python中代表最后一个元素
print(a[-1])
- python中 分割数据元素的输出
# python 中数据元素 分割输出
a = [1,2,3,4,2,3,1,-1]
# python中 此时 0:3(0、1、2) ---> 列表中第1~3位元素
print(a[0:3])
# python中 也可以省略上述写法 ---> 直接写成 :3
print(a[:3])
print(a[3:5]) # 3:5(3、4) ---> 列表第4、5位元素
print(a[5:])
print(a[-3:])
- 输出具体数值的索引 index()
# python 中输出某个值的索引
a = [1,2,3,4,2,3,1,-1]
# index() 函数参数 是具体的数值
# index(2) ---> 返回 第一次出现数值是 2 的位置索引
print(a.index(2))
- 计算列表中出现指定数值的次数是多少 count()
# count() ---> 计算列表中出现指定数值的次数是多少
a = [4,1,2,3,4,2,3,1,-1]
# a.count(4) ---> 计算列表 a 中出现数值 4 的次数是多少
print(a.count(4))
- 对列表从大到小 或 从小到大 顺序进行排序 sort()
(1) 从小到大 顺序排序
a = [4,1,2,3,4,2,3,1,-1]
# python 中对列表 从大到小 或 从小到大 顺序进行排序 ---> sort()函数
# sort() 不传入任何参数时，就会从小到大进行排序，排序之后会覆盖掉原有的列表数据
a.sort()
print(a)
(2) 从大到小 逆序排序
a = [4,1,2,3,4,2,3,1,-1]
# python 中对列表 从大到小 或 从小到大 顺序进行排序 ---> sort()函数
# 若想对列表中元素按 从大到小 顺序进行排序 则需要给sort()函数传入一个参数 reverse = True
a.sort(reverse=True) # 默认值是 reverse=False 按从小到大顺序进行排序
print(a)
9.2 多维列表
多维列表：即是将一维列表变成二维、三维列表。
# python 多维列表
# 一维列表
a = [1,2,3,4,5]
# 多维列表 三行三列 多维度 通过行数 列数来定位数值
multi_dim_a = [ [1,2,3],
[2,3,4],
[3,4,5] ]
print(a[0])
print(multi_dim_a[2][2])
10. python 字典(dictionary)
python中，字典(dictionary)与列表(list)是类似的，但字典(dictionary)会有更多的功能。
字典(dictionary)是没有顺序的。列表(list)是以一对中括号[ ]进行表示的，而字典(dictionary)是以一对大括号{ }进行表示的。
字典(dictionary)是 key : value 形式。
# python 字典(dictionary)
# 列表(list)
a_list = [1,2,3,5,4,5,4]
# 字典(dictionary)
# 字典是key : value 形式
# 字典的key是字符串(String)形式
d = {'apple':1,'pear':2,'orange':3}
# 字典的key是数字形式
d2 = {1:'a','c':'b'}
# 从字典(dictionary)中取出值
print(d['apple'])
print(a_list[0])
# 删除字典(dictionary)中的元素
del d['pear']
print(d)
# 增加字典(dictionary)中的元素
d['b'] = 20
print(d)
# 字典(dictionary)中 value 的多样形式
# 列表(list)形式 字典(dictionary)形式 数值形式
d3 = {'apple':[1,2,3] , 'pear':{1:3,3:'a'} , 'orange':2}
print(d3['pear'][3])
11. python 载入模块(import)
在脚本文件的最顶行(第一行)进行 import 。
载入模块的四种方式:
# python 载入模块(import)
# 加载模块的第一种方法
import time
print(time.localtime())
# 加载模块的第二种方法
# 此时 as 的作用是将time模块这个名字 起别名 为 t
import time as t
print(t.localtime())
# 加载模块的第三种方法 --- 只想 import 模块的指定功能，不想使用的功能不会import进来
from time import time,localtime # 只import了time模块的time功能和localtime功能
# 这种方式可以省略第一种方法中time.localtime()的time,直接打印localtime()即可
print(localtime())
print(time())
# 加载模块的第四种方法
# import了time模块中的所有功能
from time import *
# 此种方法也可以省略time,直接打印输出
print(localtime())
print(time())
11.1 python 中自己的模块
在python中，如何运用自己所创建的模块？
导入模块时需注意： 要导入的模块和此时脚本文件应处于同一个目录之下。
要导入的模块(自己的模块)程序代码 m1.py
# 充当自己的模块 需要导入的一个模块
def printData(data):
print('I am m1')
print(data)
脚本文件程序代码 python2.py
# python 载入自己的模块
# 载入 m1 模块
import m1
m1.printData('I am pyhton')
12. python 错误处理(try)
# python 错误处理(try)
# 打开文件 用只读的方式
file = open('eeee','r')
# python 错误处理(try)
try:
file = open('eeee','r')
except Exception as e:
print(e)
13. python 浅复制 & 深复制 (copy & deepcopy)
浅复制(copy)：浅复制会出现同一内存空间的情况
深复制(deepcopy)：深复制就是完完全全复制(copy)过来，任何东西都不会被重复引用到同一个内存空间
# python 浅复制 & 深复制 (copy & deepcopy)
# (复制)copy 在python中是一个模块需先载入模块
import copy
a = [1,2,3]
b = a
# id 用来输出 a b在硬盘中所处的空间地址
id(a)
id(b)
b[0] = 11
print(a)
a[1] = 22
print(b)
print(id(a) == id(b))
# 浅复制
c = copy.copy(a)
print(id(a) == id(c))
c[1] = 222222
print(a)
print(c)
a = [1,2,[3,4]]
d = copy.copy(a)
print(id(a) == id(d))
print(id(a[2]) == id(d[2]))
a[0] = 11
print(d)
a[2][0] = 333
print(d)
# 深复制 任何东西都不会被重复
e = copy.deepcopy(a)
print(id(e[2]) == id(a[2]))
14. python 存放数据(pickle模块)
pickle模块：在本地目录或多天之后想对一些数据进行再次使用，我们就可以使用pickle模块来保存python运算完的结果，以便我们之后使用。
pickle模块可以做到数据的保存和提取功能。
# python 存放数据(pickle模块)
import pickle
# 字典
a_dict = {'da':111, 2:[23,1,4], '23':{1:2, 'd':'sad'}}
# 首先打开一个文件(file)进行数据的保存
# 一般来说，pickle的保存形式文件 后缀是 .pickle
file = open('pickle_example.pickle','wb')
# dump是将a_dict 装载到file里
pickle.dump(a_dict,file)
file.close()
# python 存放数据(pickle模块)
import pickle
# 字典
a_dict = {'da':111, 2:[23,1,4], '23':{1:2, 'd':'sad'}}
file = open('pickle_example.pickle','rb')
# 读取数据
a_dict1 = pickle.load(file)
file.close()
print(a_dict1)
15. python set 功能
set功能：将所有重复的数据剔除掉，只留下不一样的那些数据。
# python set 功能
char_list = ['a','b','c','c','d','d','d']
# 使用set功能剔除掉上述列表中重复的数据，只留下不一样的数据
print(set(char_list)) # 使用set功能后 数据序列是无顺序的
sentence = 'Welcome Back to This Tutorial'
# 使用set功能剔除掉上述列表中重复的数据，只留下不一样的数据
print(set(sentence))
# python set 功能
char_list = ['a','b','c','c','d','d','d']
# 使用set功能剔除掉上述列表中重复的数据，只留下不一样的数据
unique_char = set(char_list)
# 使用set功能剔除掉重复数据之后，向新的数据序列添加元素
unique_char.add('x')
print(unique_char)
# python set 功能
char_list = ['a','b','c','c','d','d','d']
# 使用set功能剔除掉上述列表中重复的数据，只留下不一样的数据
unique_char = set(char_list)
# 使用set功能剔除掉重复数据之后，清除所有的数据信息
unique_char.clear() # 清除所有数据信息，会传回一个空的 set()
print(unique_char)
# python set 功能
char_list = ['a','b','c','c','d','d','d']
# 使用set功能剔除掉上述列表中重复的数据，只留下不一样的数据
unique_char = set(char_list)
# 使用set功能剔除掉重复数据之后，向新的数据序列添加元素 x
unique_char.add('x')
# remove 删除指定数据元素 x
# 若remove删除的数据元素并不存在于数据序列中，则系统会报错
unique_char.remove('x')
print(unique_char)
16. python 正则表达(RegEx)
正则表达式(Regular Expression)又称 RegEx，是用来匹配字符的一种工具。在一大串字符中寻找你需要的内容。它常被用在很多方面，比如网页爬虫，文稿整理，数据筛选等等。最简单的一个例子，比如我需要爬取网页中每一页的标题。而网页中的标题常常是这种形式。
# 简单匹配 --- 不使用正则表达 版本
pattern1 = 'cat'
pattern2 = 'bird'
string = 'dog runs to cat'
print(pattern1 in string)
print(pattern2 in string)
# python 正则表达(RegEx)
# 使用正则表达 匹配版本
import re # 要想使用正则表达 需导入 re 模块
pattern1 = 'cat'
pattern2 = 'bird'
string = 'dog runs to cat'
print(re.search(pattern1,string))
print(re.search(pattern2,string))
# python 正则表达(RegEx)
# 使用正则表达 匹配版本 匹配多种可能 --- 使用中括号[ ]
import re # 要想使用正则表达 需导入 re 模块
ptn = r'r[au]n' # 此时 第一个r 表示这是正则表达式。 [au]表示有a或u两种可能，ran和run
print(re.search(ptn,'dog runs to cat'))
# python 正则表达(RegEx)
# 使用正则表达 匹配版本 匹配更多种可能 --- 使用[ ]
import re # 要想使用正则表达 需导入 re 模块
print(re.search(r'r[A-Z]n','dog runs to cat')) # 此时[A-Z]可表示匹配大写字母A~Z任何其中之一
print(re.search(r'r[a-z]n','dog runs to cat'))
print(re.search(r'r[0-9]n','dog r1ns to cat')) # 此时[0-9]可表示匹配数字0~9任何其中之一
print(re.search(r'r[0-9a-z]n','dog runs to cat')) # 此时[0-9a-z]可表示既可以匹配数字0~9 又可以匹配小写字母a~z任何其中之一
正则表达的特殊种类匹配(如下表)
| 符号 | 匹配形式 |
|---|---|
| \d | 匹配所有的数字0~9 |
| \D | 与\d正好相反，匹配除数字以外的字母形式 |
| \s | 匹配所有的空白符(\t\n\r\f\v) |
| \S | 与\s正好相反 |
| \w | 匹配所有的大小写英文字母和所有数字以及下划线 _ |
| \W | 与\w正好相反 |
| \\ | 匹配反斜杠 \ |
| . | 匹配所有，除了\n |
| ^ | 匹配是否出现在句首 |
| $ | 匹配是否出现在句尾 |
# python 正则表达(RegEx)
import re # 要想使用正则表达 需导入 re 模块
# 寻找匹配所有
# findall 函数
print(re.findall(r'r[au]n','run ran ren')) # findall函数会同时匹配ran和run
# | --- or 或者
print(re.findall(r'(ran|run)','run ran ren')) # | --- 同时匹配ran或run
# python 正则表达(RegEx)
import re # 要想使用正则表达 需导入 re 模块
# 替换
# re.sub() --- 替换
print(re.sub(r'r[au]ns','catches','dog runs to cat'))
扫一扫
32万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
