python快速入门—————附完整示例代码

文章目录

• ​​0 背景​​
• ​​1 基本概念和操作​​

• ​​1.1 概念​​
• ​​1.2 操作​​

• ​​2 基本数据结构​​

• ​​2.1 list（列表）​​
• ​​2.2 tuple（元祖）​​
• ​​2.3 dict（字典）：​​
• ​​2.4 Set（集合）————字典的特殊形式​​
• ​​2.5 相互转换​​

• ​​3 条件、循环​​

• ​​3.1 条件(if)​​
• ​​3.2 循环(while)​​

• ​​4 函数（def）​​
• ​​5 异常(try,exception,else,finally)​​

• ​​5.1 捕获处理异常​​
• ​​5.2 抛出异常​​

• ​​6 文件、数据管理​​

• ​​6. 1 使用with管理文件读入​​
• ​​6.2 打开文件的方法(r,r+,a,a+,w,w+)​​
• ​​6.3 进行文件写入和读出​​
• ​​6.4 使用pickle进行数据存储和读出​​
• ​​6.5 数据库​​

• ​​6.5.1 使用mysql数据库​​
• ​​6.5.2 使用sqlite数据库​​

• ​​7 类（class）​​

• ​​7.1 基本类的创建​​
• ​​7.2 装饰器​​

• ​​7.2.1自带属性​​

• ​​7.2.1.1 property属性​​
• ​​7.2.1.2 staticmethod和classmethod属性​​

• ​​7.2.2 自定义属性​​

• ​​7.2.2.1 不带返回值、参数​​
• ​​7.2.2.2 带返回值、参数​​

• ​​7.3 继承​​

• ​​8 print使用​​
• ​​9 排序​​
• ​​10 模块​​

0 背景

因为项目涉及到做数据分析，因此需要用到python，所以借此机会学习了一些基本的python语法，学习使用的参考书籍为《Head first of python》，该书以实际的小项目为指引，从中穿插各种基本语法，学习起来也不枯燥。 本文正是以参考书籍为大纲，展开的python常用语法总结。

1 基本概念和操作

1.1 概念

• 1，BIF(build in function)：也就是内置函数，不需要任何import模块，例如print函数；
• 2，目标标识符(target identifier)：变量或函数的名称；
• 3，变量不需要声明类型，编译器会自己做类型推导；
• 4，组(suit)：代码块，通过缩进指示分组，例如：

num = [1, 2, 3, 4]
for n in num:
print(n) # 操作代码

• 5，大小写敏感；
• 6，在命令行中使用ctr/alt + p/n 查看前后指令；
• 7，字节码：文件后缀名为pyc，当你import自己写的模块时，为了防止Python每次运行时都重新解析源代码而生成的（防在__pycache__的子目录中），目的时加快程序运行；
  
• 8，查看模块的位置：

import sys
print(sys.path)

• 9,切片
  格式：[起始偏移量 start:终止偏移量 end[:步长 step]]
  注意：左封右开

name2 = 'qwer'
print(name2[0:2])
# 打印qw

• 10，打印模块中的所有变量和方法:

import math
print(dir(math))

• 11，返回全局和局部命名空间里的名字

print(locals())
print(globals())

• 12，方法串链(从左到右)

data = ' 12345,789'
print(data.strip().split(','))

• 13，函数串链（从右到左）

data = [1, 5, 2, 4]
print(sorted(data))

• 14，工厂函数
  创建某种类型的新数据线：

例如：

a = dict() # 创建字典类型数据

1.2 操作

name = ['江雪韩', 'hjx']
print(type(name)) # 查看数据类型
print(len(name)) # 查看长度
if isinstance(name, list): # 判断类型
print("It's list")
print(id(name)) # 打印id
for i, n in enumerate(name): # 列出数据和数据下标
print('i: ' + str(i) + ' n:' + n)
name2 = 'qwer'
for i in range(len(name2)): # 打印字符串 range(start,stop[,step]) 开始，结束，步长
print(name2[i])

2 基本数据结构

2.1 list（列表）

特点：可以存储任何类型的数据

[]

操作：

sch = []
sch.append("中科大") # 追加到末尾
sch.extend("南大", "浙大") # 添加列表
sch.insert(1, "复旦") # 在第二个位置添加元素
sch.pop(1) # 在删除第二个元素
shc.remove('浙大') # 移除第一个出现的元素
shc.index('中科大') # 打印元素的位置
shc.count('中科大') # 获得指定元素在列表中出现的次数

2.2 tuple（元祖）

特点：不可改变,可以理解为常量类型的列表

（）name = ('江雪')

2.3 dict（字典）：

特点：就像map一样，有键和值，一个键可以对应多个值

{}

操作

sch = {1:'南大', 2:'浙大'}
sch.keys() # 取出所有key值
sch.values() # 取出所有values值
#遍历键和值
for key,value in sch.items():
print(str(key) + ": " + str(value))
# 按键排序
sch = sorted(sch.items(), key=lambda sch: sch[0]) # ,reverse=True 是否降序排列
sch = dict(sch) # 重现转为idct
# 按值排序
sch = sorted(sch.items(), key=lambda x: x[1], reverse=True) # reverse为是否降序排列
sch = dict(sch)

2.4 Set（集合）————字典的特殊形式

特点：只有键的字典，不能重复的且唯一

a = [1,2,3,1]
b = set(a) # 将列表、元组等可迭代对象转成集合

2.5 相互转换

列表转换（字典、元祖、集合）：

a = [5, 3, 2, 4, 2]
b = ['c', 'p', 'j']
c = dict(zip(a, b)) # 转字典
print(type(c), c)
d = tuple(a) # 转元祖
print(type(d), d)
e = set(a) # 转集合
print(type(e), e) # {2, 3, 4, 5}

元祖转换（同上）：

a =(5, 3, 2, 4, 2)
b = ['c', 'p', 'j']
c = dict(zip(a, b)) # 转字典
print(type(c), c)
d = tuple(a) # 转元祖
print(type(d), d)
e = set(a) # 转集合
print(type(e), e) # {2, 3, 4, 5}

字典转换(元祖、列表、集合)：

dict1 = {1:'a',2:'b',3:'c'}
print(list(dict1.keys()))
print(list(dict1.values()))
print(tuple(dict1.keys()))
print(tuple(dict1.values()))
print(set(dict1.keys()))
print(set(dict1.values()))
print(tuple(dict1.items())) #生成元祖为单位的元祖
print(list(dict1.items())) #生成元祖为单位的列表
print(set(dict1.items())) #生成元祖为单位的集合

3 条件、循环

3.1 条件(if)

格式：

if 条件:
# 组
elif 条件：
# 组
else:
# 组

注意：使用not可以对条件取反

3.2 循环(while)

格式：

for 目标标识符 in 序列:
# 组

4 函数（def）

作用：复用需要重复使用的代码
格式：

def 函数名 (参数列表)：
函数方法

5 异常(try,exception,else,finally)

5.1 捕获处理异常

格式

try:
# 捕捉异常
# raise IOError
except IOError as err: # 异常发生时执行
# 处理异常
print('The file is not writting' + str(err))
# 忽律异常
pass # 空语句或null语句
else:
print('没有异常发生')

finally: # 异常无论是否发生，都会执行
print('finally')

5.2 抛出异常

raise [Exception [, args [, traceback]]]

语句中 Exception 是异常的类型（例如，NameError）参数标准异常中任一种，args 是自已提供的异常参数。

最后一个参数是可选的（在实践中很少使用），如果存在，是跟踪异常对象。

6 文件、数据管理

6. 1 使用with管理文件读入

不使用with读入语句：

try:
data = open('/Users/mac/test.txt')
print(data.readline(), end='')
except IOError as err:
print('File Error: '+ str(err))
finally:
if 'data' in locals(): # 如果文件被打开
data.close()

使用上下文管理器with（不需要手动关闭打开的文件）:

try:
#上下文管理
with open('/Users/mac/数据科学/test.txt', 'a+') as data:
print("It is...", file=data)
except IOError as err:
print('File Error: '+ str(err))

6.2 打开文件的方法(r,r+,a,a+,w,w+)

默认的打开方式是r

""""
a,a+的方式打开文件，附加方式打开
a：附加写方式打开，不可读；a+: 附加读写方式打开

w新建只写，w+新建读写，二者都会将文件内容清零，即事先不需要有该文件存在，若已经存在则会覆盖
w方式打开，不能读出;w+可读写

r只读，r+读写，不创建，即需要事先存在一个文件以供读/读写，若不存在文件会报错
"""""

6.3 进行文件写入和读出

例子：

import sys
def test_print(the_list, f = sys.stdout):
print(the_list, end='', file=f)

try:
# 写文件
with open('/Users/mac/PycharmProjects/hello/test3.txt', 'w') as file:
test_print([1, 2, '3'], file)
# 文件读出
with open('/Users/mac/PycharmProjects/hello/test3.txt', 'r') as file:
data = file.readline()
print(data)
except IOError as err:
print('File Error: '+ str(err))

6.4 使用pickle进行数据存储和读出

要求以二进制方法打开文件:

格式：

import pickle
try:
# 写文件
with open('/Users/mac/PycharmProjects/hello/test.pickle', 'wb') as data:
pickle.dump([1, 2, 'a'], data)
# 读文件
with open('/Users/mac/PycharmProjects/hello/test.pickle', 'rb') as data:
a_list = pickle.load(data)
print(a_list)
except IOError as err:
print('File Error: '+ str(err))

6.5 数据库

6.5.1 使用mysql数据库

import pymysql
try:
conn = pymysql.connect(host='127.0.0.1', user='root', passwd='root', db='db_testAnalyzeData', port=9996, charset='utf8') # 连接数据库
cur = conn.cursor() # 使用游标
try: # 执行sql语句
cur.execute('SELECT * FROM Customers')
db.commit() # 提交修改
except: # 出现错误，则回滚
db.rollback()
data = cur.fetchall()
for d in data:
print("cust_id: " + str(d[0]) + ' cust_name：' + d[2])
cur.close() # 关闭游标
conn.close() # 关闭数据库连接
except Exception:
print('查询失败')

使用通配符：

cur.execute(
"SELECT quantity,to_big_ratio,is_refund,create_time FROM trans_detail WHERE com_name = %s",
(commodityName))

6.5.2 使用sqlite数据库

import sqlite3
connection = sqlite3.connect('data.sqlite')
cursor = connection.cursor()
# 使用通配符
cursor.execute("INSERT INTO school(name, dob) VALUES (?,?)", (name, dob))
cursor.close()
connection.close()

7 类（class）

类的方法（method）：代码（共享）
类的属性（attribute）：数据（不贡献）
类的实例：实例化后的数据对象

7.1 基本类的创建

其中self为指向类的指针

# 类测试
class Athlete:
# 构造函数
def __init__(self, a_name, a_age = None, a_grade = dict()):
self.name = a_name
self.age = a_age
self.grades = a_grade
# 析构函数
def __del__(self):
self.name = ''
self.age = 0
self.grades = {}
# 比较
def __cmp__(self, other):
if self.age > other.age:
print('你有点年轻')
elif self.age < other.age:
print('你有点成熟')
else:
print('刚刚好')
# 下面两个方法作用相同，都是打印类信息
def __repr__(self):
# 在命令端口输入对象名，也可以输出
return ('Athlete Class：name、age、grades')
def __str__(self):
# 只能使用print(对象)
grade = ''
for key, value in self.grades.items():
grade += str(key) + ':' + str(value)
return (self.name + ' ' + str(self.age) + ' ' + grade)
# 对字典进行操作
def __getitem__(self, key): # 返回字典值
if key == '田径': return self.grades['田径']
elif key == '游泳': return self.grades['游泳']
elif key == '健身': return self.grades['健身']
else: return 'unknown'
def __setitem__(self, key, value): # 设置字典值
self.grades[key] = value
def __delitem__(self, key): # 删除字典值
del self.grades[key]
a = Athlete('jiangxuehan', 42, {'田径':98, '游泳':82, '健身':90})
b = Athlete('james', 36, {'田径':90, '游泳':96, '健身':98})
a['田径'] = 92
del a['游泳']
print(a)
a.__cmp__(b)
a.__del__()
print(a)

__repr__和__str__的区别：

7.2 装饰器

7.2.1自带属性

7.2.1.1 property属性

使用了property属性的方法，调用时不需要加()，为的是提供更加友好访问类数据的方式。

class people:
def __init__(self, name):
self._name = name
self._age = 20
@property # 设置为属性
def age(self):
print('@property')
return self._age
@age.setter # 设置属性值
def age(self, value):
if not isinstance(value, int):
raise ValueError('年龄非法')
if value < 0 or value > 120:
raise ValueError('年龄非法')
self._age = value
@age.getter # 返回属性值
def age(self):
print('@age.getter')
return self._age
@age.deleter # 删除属性值
def age(self): # 删除后就找不到对象属性
del self.age

p = people('james')
print(str(p.age))
people.age = 60
print(str(p.age))
del p.age
print(str(p.age)) # 因为属性被删，会报错，AttributeError: age

7.2.1.2 staticmethod和classmethod属性

共同点：

都可以通过不示例化类，就可以直接调用

区别：

classmethod由于默认传递了一个类的本身（cls），因此可以调用类中不需要示例化的方法和数据，用于初始化参数等用途。

class A():
number = 0
@staticmethod
def static_test():
print('static_test')
@classmethod # 只在类中运行而不在实例中运行的方法
def classmethod_test(cls): # 参数cls就是类本身
print('classmethod_test')
cls.number = 20
cls.test() # 调用可以不示例化的方法
def test():
print('test')
def print_number(self):
print(str(self.number))
a = A()
a.print_number()
A.static_test()
A.classmethod_test()
# a.classmethod_test()
a.print_number()

7.2.2 自定义属性

作用：再不修改已有函数的前提下，扩充已有函数。

7.2.2.1 不带返回值、参数

调用的顺序为：run_time—>warp—>foo

import time

def run_time(func):
def warp():
start = time.time()
temp = func() # 执行函数
end = time.time()
print('程序执行时间: ',end - start)
print('warp')
return warp

@run_time
def foo():
print('hello')

foo()
# 等同与不用装饰器的foo
# foo = run_time(foo)
# foo()

7.2.2.2 带返回值、参数

用例：

import time

def run_time(func):
def warp(*args, **kwargs):
print(type(args)) #
print(type(kwargs)) #
print(args) # foo的参数列表
# ({'a': 1, 'b': 2, 'c': 3},)
print(kwargs)
# {'arg2': '1234', 'arg3': 'hahaha', 'arg4': 'lalalala'}
start = time.time()
temp = func(*args, **kwargs) # 执行函数
end = time.time()
print('程序执行时间: ', end - start)
return temp
return warp

@run_time
def foo(n, **kwargs):
temp_num = 2
return(n['a'] + 1)*temp_num

print(str(foo({'a':1,'b':2,'c':3}, arg2 = '1234', arg3 = 'hahaha', arg4 = 'lalalala')))
# 等同与不用装饰器的foo
# foo = run_time(foo)
# foo()

*args：用于可变长参数；

**kwargs：用于键值参数。

def test_args(*args):
print(type(args))
print(args)
def test_kwargs(**kwargs):
print(type(kwargs))
print(kwargs)
test_args(1,2,'1231')
test_kwargs(arg1 = 1, arg2 = '12', arg3 = 'asdf')
# 输出：
#
# (1, 2, '1231')
#
# {'arg1': 1, 'arg2': '12', 'arg3': 'asdf'}

7.3 继承

class A(list):
def __init__(self, number):
list.__init__([]) # 初始化父类
self.number = number

a = A([1,2,3])
a.append(9)
print(a)

8 print使用

格式：

import sys
print(value, sep = '', end='\n', file = sys.stdout)

sep：

用来间隔多个对象，默认值是一个空格。也可以输入特定的值（符号、数字、中文都可）来间隔内容。
end：用来设定以什么结尾，默认值是换行符"\n"。也可以输入其他值来结尾。
file：输出的文件，默认为输出到屏幕。

测试：

a = 'qwer'
b = 2
print(a, b, sep=' | ',end='', file=open('test23.txt','w'))

9 排序

sort和sorted的区别：

sort():原地排序，对原始序列进行改变；

sorted():复制原始序列，对新序列进行排序，并返回，不会修改原始序列。

测试：

a = [1,5,4,2]
print(sorted(a)) # [1, 2, 4, 5]
print(a) # [1, 2, 4, 5]
a.sort()
print(a) # [1, 2, 4, 5]

10 模块

格式：

import 模块名
from 模块 import 函数

示例：

import math
from time import sleep
math.cos(2)
sleep(2) # 不使用包名