Python 基础

前言：python基础类型和文件操作，python入门的最佳选择。

1.Python变量和数据类型

2.Python中输入输出
2.1.基本形式输出
print();

2.2.格式化输出
print(“我芳龄18岁”);
print(“我芳龄20岁”);
print(“我芳龄22岁”);

2.3.换行输出

2.4.基本输入
a=input(“sss”)
3.运算符
python支持以下几种运算符

3.1.算术运算符

• 加 +
• 减 -
• 乘 *
• 除 /
• 取整数 //
• 取余 %
• 幂 **

3.2.赋值运算符
= 把右边的结果，给左边的变量
a,b=1,2

3.3.复合赋值运算符

3.4.比较运算符

3.5.逻辑运算符

3.5.1.and
两个都为真，则为真。
从左到右计算表达式，若所有值均为真，则返回最后一个值，若存在假，返回第一个假值

3.5.2.or
当有一个条件为真时，该条件即为真。
从左到右计算表达式，若为真，则返回第一个真值，若为假，则返回第二个假值

3.5.3.not
not True —>False
not False—>True

4.条件判断
4.1.if 判断语句
if 比较运算符
案例: 判断是否是成年人

if 逻辑运算符
* or
案例: 有房子或者有车，都可以
* and
案例: 是否钻石王老五
* not
案例:判断数字范围
a = 30
if not (a>0 and a<=50):
print(“在0到50之间…”)

4.2.if else判断
高富帅案例

4.3.if elif else 判断
案例:三好学生评选

5.while循环判断
求偶数的和

6.for循环操作
和while循环类似，for循环可以完成循环的操作
在python中，for循环可以遍历任何序列的项目，如一个列表或者一个字符串等。

6.1.for循环遍历字符串
输入任意一个字符串，将字符串中字母打印出来

6.2.for循环计算1-100的和

7.字符串切片
切片概念:切片是对操作的对象截取一部分的操作，字符串，列表，元组都支持切片操作。切片的语法[起始:结束:步长]

name[0:5]
name[1:5]
name[:3] 从0到3
name[::2] 从头到尾 2步数
name[4:1] 没有内容
name[5:1:2]
name[4:1:-1]

案例:字符串反转
[::-1]

8.字符串常见操作

8.1.find
find 检测str是否包含在mystr中，如果是返回开始索引值，否则返回-1

8.2.rfind
rfind 类似于find，不过是从右边开始找。

8.3.count
检测mystr中出现str的次数

8.4.replace 替换
把mystr中的str1替换成str2，如果count指定，则替换不超过count次

8.5.split
name.split(",") 全部分隔
name.split(“hello”,1) 分隔第一个

t

8.6.startswith
以什么进行开头，如果是，返回True，如果不是，返回False。

8.7.endswith

8.8.strip
name=" hello world "

去除左右空格

8.9.isalpha
判断是否都是字母，如果是，返回True，如果不是，返回False

8.10.isdigit
判断是否都是数字，如果是，返回True，如果不是，返回False
8.11.isalnum
判断所有是否都是字母或数字，如果是返回True，如果不是返回False
8.12.len() 非字符串方法
获取字符串（列表）长度

9.列表 list
存储一系列名字，存储一些新闻条目，可以使用列表的格式。

9.1.列表的基本形式
names=[“张三”,“李四”,“王五”,“赵六”]
ages=[1,4,6,9]
s=[1,“哈哈”,“呵呵”,True]

9.2.获取列表中元素
9.2.1.根据下标(索引)获取
print(names[0])
print(names[1])
print(names[-1])
9.2.2.切片操作
print(names[0:3])#索引0-2的元素
print(names[0::2])#步长为2，索引0-2的元素
print(names[::-1])#步长为1，倒序遍历
print(names[3:0:-1])#步长为-1，倒序遍历，索引3 2 1

9.3.列表的循环遍历
9.3.1.for循环
#列表
names=[“张三”,“李四”,“王五”,“赵六”]
for name in names:
print(name)

9.4.列表常见的操作
9.4.1. append 增加元素
9.4.2.extend 可以将另外一个集合中的元素逐一添加到列表中
9.4.3.insert 在指定位置插入元素
insert(index,object) 在指定位置处插入元素object
9.4.4.修改元素
修改元素的时候，只需要获取到对应的下标，就可以重新赋值，就完成了修改
nums[1]=100

9.4.5.查找元素 in not in
python中常见的查找方法为:
in(存在),如果存在那么结果为True，否则为False
not in (不存在),如果不存在那个结果为True，否则为False

姓名查找案例：
#列表
names=[“张三”,“李四”,“王五”]
name=input(“请输入要查询的姓名?\n”)
if name in names:
print(“存在”)
else:
print(“不存在”)

9.4.6.index count
index 获取某元素在列表中的索引值
count 获取元素在列表中出现的次数

#列表
names=[“张三”,“李四”,“王五”,“李四”,“王五”]
name=“李四”
print(names.index(name))#查找索引
print(names.count(name))#查找个数

9.4.7.删除元素
del:根据元素下标进行删除
starNames=[“张三”,“李四”,“王五”,“李四”,“王五”]
#del 根据下标进行删除
del starNames[2]
print(starNames) #[“张三”,“李四”,“李四”,“王五”]

remove:根据元素的值进行删除
starNames.remove(“李四”)#[“张三”,“李四”]
print(starNames)

10.元组 tuple
python中元组和列表类似，不同之处在于元组的元素不能更改，元组使用小括号，list使用中括号。

tuple=(“abc”,“bcd”,“efg”)

10.1.根据下标和切片获取元素
print(tuple[0]) #abc
print(tuple[0:1]) #abc bcd efg

10.2.元组中内置函数count index
tuple=(“abc”,“bcd”,“efg”,“bcd”)
print(tuple.index(“abc”)) #0
print(tuple.count(“bcd”)) #2

11.字典介绍

key value(键值对)形式数据对应，比如 name：张三 age：18 sex:男 JSON

info={“name”:“张三”,“age”:18,“sex”:“男”}

11.1.元素获取
print(info[“name”])如果元素没有会报错误
print(info.get(“name”)) #
#print(info.get(“xx”))

11.2.字典的增删改操作
11.2.1.修改元素
字典中每个元素都是可修改的，只要通过key找到，既可以修改Demo
info[“name”]=“李四”
11.2.2.添加元素
想要添加元素，只需要指定key 指定 value就可以

info[“address”]=“北京”

11.2.3.删除元素
对字典进行删除操作，有以下两种方式：
del info[] 指定要删除的元素

del info[“name”]

clear 清空元素
info.clear()

11.3.字典的常见操作
11.3.1.len() 获取字典的长度

11.3.2.
keys() 获取字典的所有key 列表

print(info.keys())

11.3.3.values 获取字典的所有values 列表

print(info.values())

11.3.4.items 返回一个包含所有元组(键，值)的列表

print(info.items())

11.4.字典的遍历

11.4.1.遍历key
#遍历key
for key in info.keys():
print(key)

11.4.2.遍历value
#遍历value
for value in info.values():
print(value)

11.4.3.遍历items
#遍历items
for item in info.items():
print(item)

11.4.4.遍历key value
#遍历key value
for key,value in info.items():
print(key,value)

12.函数定义、调用
12.1.定义函数的格式如下
def 函数名():
代码

13.函数参数
13.1.定义带有参数的函数:
def printSum(a,b):
print(a+b)

13.2.形式参数和实际参数
定义时小括号中的参数，用来接受参数用的,称为“形参”
调用时小括号中的参数，用来传递给函数用的，称为”实际参数”

13.3.缺省参数
默认有参数值的函数
def printInfo(name,age=23):
print(name,age)
printInfo(“张三”)

13.4.可变参数(一 元组类型)
def getSum(*args):
print(args)
sum=0
for i in args:
sum+=i
return sum
print(getSum(1,2,3,4))

13.5.可变参数(二 字典类型)
def printKeyValue(**kwargs):
print(kwargs)
getSum(m=6,n=10)

14.函数类型
无参数，无返回值
无参数，有返回值
有参数，无返回值
有参数，有返回值

14.1.无参数，无返回值的函数
案例:简单操作，没有参数，没有返回值，简单打印。

14.2.无参数，有返回值的函数
案例:比如获取当前温度。

15.主函数
if name == ‘main’:

16.文件打开与关闭
python中打开文件，可以使用open函数，可以打开一个已经存在的文件，或者创建一个新的文件。
open(文件名，访问模式)
比如
#Python写入内容
file=open(“test.txt”,“w”)
file.write(“哈哈哈”)
file.close()
16.1.文件访问模式

17.文件备份
17.1.案例 将一个文本文件拷贝一份，并命名为aa.py
import os
#打开源文件
f1=open(“text.txt”,“r+”)
f2=open(“aaa.txt”,“w+”)
for line in f1.readlines():
f2.write(line)
f1.close()
f2.close()

18.定义类
定义一个类，格式如下。
class 类名:
方法列表

18.1.定义一个car类，拥有移动的方法，鸣笛的方法(toot)
class Car:
def move(self):
print(“car在移动”)
def toot(self):
print(“car在鸣笛”)

18.2.定义对象
#创建car对象
bmw=Car()
bmw.color=“黑色”
bmw.wheelNum=4 #轮子数量
bmw.move()
bmw.toot()

print(bmw.color)
print(bmw.wheelNum)
19.__init__方法
19.1.使用方式

def init(self):
pass

19.2.__init__调用
def init(self):
print(“init__方法执行了”)
19.3.在_init__方法中进行属性初始化
def init(self):
self.color=“黑色”
self.wheelNum=4
19.4.使用__init__方法传递参数
def init(self,newcolor,wheelNum):
self.color=newcolor
self.wheelNum=wheelNum

20.封装
如果有一个对象，当需要对其进行属性修改的时候，有两种方法

对象名.属性名=数据----->直接修改
对象名.方法名()----->间接修改

为了更好的保存属性安全，即不能随意修改，一般的处理方法为

将属性定义为私有属性
添加一个可以调用的方法，供调用。

20.1.属性封装

def setAge(self,age):
if age>150 or age<0:
print(“年龄错误”)
else:
self.__age=age
def getAge(self):
return self.__age
20.2.方法私有
def __getHeart(self):
print(“把心脏逃出来看一看”)

20.3.总结:
私有的属性，不能通过属性直接调用，但是可以通过方法直接访问

私有的方法，不能通过对象直接调用,只能内部调用。

21.继承介绍以及单继承
21.1.继承概念
儿子继承爹的财产

在程序中,继承描述的是事物之间的所属关系,例如猫和狗都属于动物.

21.2.继承特点

class Dog(object):
def init(self,name,color=“黄色”):
self.name=name
self.color=color
def run(self):
print("%s在跑着"%self.name)

class JinMao(Dog):
def setNewName(self,name):
self.name=name
def eat(self):
print("%s在吃饭，颜色是%s"%(self.name,self.color))

dog1=JinMao(“大黄”)
dog1.run()
dog1.setNewName(“小阿黄”)
dog1.eat()

说明:虽然子类没有定义__init__方法，但是父类有，所以在子类继承父类的时候这个方法被继承了，所以只要创建子类的对象，就默认执行了这个init方法.

21.3.私有属性的继承
21.3.1.案例
class Person(object):
def init(self,name,color=“黄色”):
print(“父类的init方法”)
self.__name=name
self.color=color

def run(self):
    print("%s在跑着"%self.__name)

class HungPerson(Person):

def setNewName(self,name):
    self.name=name

def eat(self):
    print("%s在吃饭，肤色是%s"%(self.__name,self.color))

p1=HungPerson(“张三”)
p1.eat()

21.3.2.总结:

私有的属性和方法，不能被子类继承，也不能被访问。
一般情况下，私有的属性，方法是不对外公布的，往往用来做内部的事情，起到安全的作用。

22.重写父类方法及调用父类方法
class Dog(object):
def init(self,name,color=“黄”):
self.name=name
self.color=color
def play(self):
print(“玩尾巴”)

class JingBa(Dog):
def init(self,name):
super().init(name)

def play(self):
    super().play()
    print("%s颜色的%s抓老鼠"%(self.color,self.name))

d=JingBa(“京巴”)
d.play()
23.类属性和对象属性
类属性就是类(类对象)所拥有的属性。它被类和所有对象所拥有。对于共有类属性，在类外可以通过类对象和实例对象访问。

23.1.类属性
class Dog(object):
name = “Tom”
__age = 10

print(Dog.name)#正确
print(Dog.__age)#错误

d=Dog()
print(d.name)#正确
print(d.__age)#错误

23.2.对象属性
def init(self,name):

self.name=name

print(Dog.name)#Tom
d=Dog(“大黄”,19)
print(d.name)#大黄
print(d.getAge())
def getAge(self):
return self.__age
24.类方法方法
24.1.类方法
类方法，是类对象所拥有的方法，需要用修饰器@classmethod来标识其为类方法

对于类方法，第一个参数通常是类对象本身

24.1.1.使用类方法调用类属性

class Person(object):
country=“北京”
@classmethod
def getCountry(cls):
return cls.country;

print(Person.getCountry())
p=Person()
print(p.getCountry())

24.1.2.使用类方法修改类属性
@classmethod
def setCountry(cls,name):
cls.country=name

Person.setCountry(“美国”)

25.异常介绍
当python检测到一个错误时，解释器就无法继续执行了，反而出现一些错误提示，这就是所谓的“异常”。

算术异常
文件不存在异常
类型转换异常

26.捕获异常

try:
print(“test1=====”)
i=1/0
print(“test2=====”)
except ArithmeticError:
pass

程序捕获异常之后，就看不到任何错误。

总结:把可能产生的错误放置到try中
把处理异常的代码，放在except中

27.获取异常信息描述
try:
print(“test1=====”)
i=1/0
print(“test2=====”)
except ArithmeticError as result:
print(result)

28.except捕获多个异常
28.1.出现数学异常时捕获
try:
print(“test1=====”)
i=1/0
print(“test2=====”)
except (ArithmeticError,IndexError) as result:
print(result)

print(“普通的打印”)
28.2.出现角标越界时捕获
try:
print(“test1=====”)
#i=1/0
print(“test2=====”)
list=[1,2]
print(list[10])
except (ArithmeticError,IndexError) as result:
print(result)

print(“普通的打印”)

28.3.捕获所有异常
try:
print(“test1=====”)
#i=1/0
print(“test2=====”)
list=[1,2]
print(list[10])
except Exception as result:
print(result)

print(“普通的打印”)
29.else
except Exception as result:
print(result)
else:
print(“没有捕获到异常，可开心了”)
29.1.try…finally
#案例:文件操作异常，文件关闭
try:
file=open(“aaa.txt”,“w”)
i=1/0
except Exception as result:
print(result)
finally:

file.close()
print("文件关闭")

异
30.异常抛出
#自己抛出异常
def testAge(age):
if age>150 or age<0:
raise Exception(“年龄范围不对”)
testAge(199)
31.Python中模块基本导入

模块就好比是工具包，要想使用这个工具包的工具，就需要导入这个模块。
在Python中用关键字import来引入模块，比如要引入模块(文件)，math，就可以在文件最开始的地方用import math来引入。

31.1.格式:一 import module1,module2…
31.1.1.普通导入
当使用import语句，模块内容就会被导入。
调用方式
模块名称.函数名()
import math
print(math.sqrt(10))
#print(sqrt(20)) 不能这样写
31.1.2.导包并改名

import math as HaHa
print(HaHa.ceil(10))

31.2.格式二 from 模块名 import 函数名2,函数名3

31.2.1.from math import …导入函数
from math import sqrt
print(sqrt(10))

31.2.2.from math import *
from math import *
print(sqrt(10))
print(ceil(12.8))

32.Python数据库编程前提
熟练使用sql语句的基础上，开始使用python语言提供的模块与mysql进行交互
这是我们在工作中大事要做的事
先学会sql是基础，一定要熟练编写sql语句

33.安装引入模块

安装mysql模块
pip install pymysql 3.6版本

在文件中引入模块
import pymysql

34.Connection对象
用于建立与数据库的连接
创建对象：调用connect()方法
conn=connect(参数列表)
参数host：连接的mysql主机，如果本机是’localhost’
参数port：连接的mysql主机的端口，默认是3306
参数db：数据库的名称
参数user：连接的用户名
参数password：连接的密码
参数charset：通信采用的编码方式，默认是’gb2312’，要求与数据库创建时指定的编码一致，否则中文会乱码

35.对象的方法
close()关闭连接
commit()事务，所以需要提交才会生效
rollback()事务，放弃之前的操作
cursor()返回Cursor对象，用于执行sql语句并获得结果
36.Cursor对象
执行sql语句
创建对象：调用Connection对象的cursor()方法
cursor1=conn.cursor()
36.1.对象的方法
close()关闭
execute(operation [, parameters ])执行语句，返回受影响的行数
fetchone()执行查询语句时，获取查询结果集的第一个行数据，返回一个元组
fetchall()执行查询时，获取结果集的所有行，一行构成一个元组，再将这些元组装入一个元组返回

37.增删改
37.1.向数据库中添加一条数据

if name == ‘main’:
#参数host：连接的mysql主机，如果本机是’localhost’
# 参数port：连接的mysql主机的端口，默认是3306
# 参数db：数据库的名称
# 参数user：连接的用户名
# 参数password：连接的密码
# 参数charset：通信采用的编码方式，默认是’gb2312’，要求与数据库创建时指定的编码一致，否则中文会乱码
connect=pymysql.connect(host=“localhost”, user=“root”, password=“root”, db=“mydb1”, port=3306, charset=“utf8”)
#获取连接的游标
cursor=connect.cursor()
#定义sql语句
sql1=“insert into student values(0,‘吼吼’,‘男’)”
cursor.execute(sql1)
#提交
connect.commit()
#关闭游标
cursor.close()
#关闭连接
connect.close()

37.2.修改
sql1=“update student set sex=‘女’ where name=‘zhangsan’”

37.3.删除
sql1=“delete from student where name=‘zhangsan’”

38.参数化操作
name=input(“请输入要添加的姓名:\n”)
sex=input(“请输入要添加的性别:\n”)
parmas=[name,sex]
#定义sql语句
sql1=“insert into student values(0,%s,%s)”
cursor.execute(sql1,parmas)

39.查询操作
39.1.查询一行数据
cursor=connect.cursor()
sql=“select * from student where id=2”
cursor.execute(sql)
#获取一个
result=cursor.fetchone()
print(result)

39.2.查询所有数据
cursor=connect.cursor()
sql=“select * from student”
cursor.execute(sql)
#获取一个
result=cursor.fetchall()
for r in result:
print®

39.3.查询多行数据
#获取多个
result=cursor.fetchmany(3)

40.封装操作数据库工具类

观察前面的文件发现，除了sql语句及参数不同，其它语句都是一样的
创建MysqlHelper.py文件，定义类
增加(Create)、读取查询(Retrieve)、更新(Update)和删除(Delete)

encoding=utf8

import pymysql
import pymysql.cursors
class MysqlHelper():
def init(self, host=“localhost”, port=3306, db="", user=“root”, password=“root”, charset=“utf8”):
self.host = host
self.port = port
self.db = db
self.user = user
self.password = password
self.charset = charset

# 获取连接并获取cursor
def connect(self):
    self.conn = pymysql.connect(host=self.host, port=self.port, db=self.db, user=self.user, password=self.password,
                                charset=self.charset)
    self.cursor = self.conn.cursor()

def close(self):
    self.cursor.close()
    self.conn.close()

def cud(self, sql, params=()):
    count = 0
    # try:
    # 先连接一把
    self.connect()
    count = self.cursor.execute(sql, params)
    self.conn.commit()

# except Exception as result:
#     print(result)
    return count


def getOne(self,sql,params=()):
    result = None
    try:
        self.connect()
        self.cursor.execute(sql,params)
        result = self.cursor.fetchone()
        self.conn.commit()
        self.close()
    except Exception as r:
        print(r)
    return result


def getAll(self, sql, param=()):
    result = None
    try:
        self.connect()
        self.cursor.execute(sql, param)
        result = self.cursor.fetchall()
        self.conn.commit()
        self.close()
    except Exception as r:
        print(r)
    return result

40.1.测试
class SQLTest(unittest.TestCase):
def testAdd(self):
mysqlHelper=MysqlHelper(db=“mydb1”)
mysqlHelper.cud(“insert into student (name,sex) values(%s,%s)”,params=(“zhangsan”,“男”))

def testUpdate(self):
    mysqlHelper = MysqlHelper(db="mydb1")
    mysqlHelper.cud("update student set sex =%s where id <%s",params=("男",10))

def testFetchOne(self):
    mysqlHelper = MysqlHelper(db="mydb1")
    result=mysqlHelper.getOne("select * from student where id=%s",params=(4))
    print(result)

def testFetchAll(self):
    mysqlHelper = MysqlHelper(db="mydb1")
    result = mysqlHelper.getAll("select * from student")
    print(result)

if name == ‘main’:
unittest.main()