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

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) # <class 'set'> {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) # <class 'set'> {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)) # <class 'tuple'>
        print(type(kwargs)) # <class 'dict'>
        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')
# 输出:
# <class 'tuple'>
# (1, 2, '1231')
# <class 'dict'>
# {'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)

seq:用来间隔多个对象,默认值是一个空格。也可以输入特定的值(符号、数字、中文都可)来间隔内容。
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) # 不使用包名
相关推荐
©️2020 CSDN 皮肤主题: 岁月 设计师:pinMode 返回首页