python基础应用 python基础应用与开发

目录

• 读书笔记

• 《Python程序设计——从基础到开发》第一章_Python代码规范&帮助
• 《Python程序设计——从基础到开发》第二章_Python语法基础
• 《Python程序设计——从基础到开发》第三章_Python控制语句
• 《Python程序设计——从基础到开发》第四章_Python函数与模块
• 《Python程序设计——从基础到开发》第五章_Python文件的使用
• 《Python程序设计——从基础到开发》第六章_面向对象程序设计
• 《Python程序设计——从基础到开发》第八章_Python数据库应用

• 一些入门级代码块

• 字符串格式化输出
• 布尔类型练习
• 数字类型转换
• 逻辑运算
• 列表
• 多维列表
• 元组
• 字典
• 集合
• for循环
• 函数
• 游戏-猜单词
• 参数
• 闭包
• 递归 汉诺塔问题
• 扑克牌发牌程序
• 读文件的三种方式
• 关闭文件
• 文件夹操作
• 文件操作1
• 文件操作2
• 实例属性和类属性
• types.MethodType
• 继承_super()
• 继承2
• 运算符重载
• 读取数据库内容1
• 读取数据库内容2

• 结语（小小声的废话）

读书笔记

《Python程序设计——从基础到开发》第一章_Python代码规范&帮助

《Python程序设计——从基础到开发》第二章_Python语法基础

《Python程序设计——从基础到开发》第三章_Python控制语句

《Python程序设计——从基础到开发》第四章_Python函数与模块

《Python程序设计——从基础到开发》第五章_Python文件的使用

《Python程序设计——从基础到开发》第六章_面向对象程序设计

《Python程序设计——从基础到开发》第八章_Python数据库应用

一些入门级代码块

字符串格式化输出

#字符串格式化输出
charA = 65
charB = 66
print("ASCII码65代表:%c" % charA)
print("ASCII码66代表:%c" % charB)

Num1 = 0xFF
Num2 = 0xAB03
print('转换成十进制分别为：%d和%d' % (Num1,Num2))
Num3 = 1200000
print('转换成科学计数法为:%e' % Num3)
Num4 = 65
print('转换成字符为:%c' % Num4)

布尔类型练习

#布尔类型练习
print(False or False)
a = 'python'
print(a and True)
print(a or True)
b = ''
print(b and False)
print(b or False)

数字类型转换

#数字类型转换
x = 20 #八进制为24
y = 345.6
print(oct(x)) #0o24
print(int(y)) #345
print(float(x)) #20.0
print(chr(65)) #A
print(ord('B')) #66
print(ord('中')) #20013
print(chr(20018)) #串

逻辑运算

#逻辑运算
a = True
b = 0
print(a and b)

列表

#列表
print("输出列表")
list1 = ['中国','美国',1997,2000];
list2 = [1,2,3,4,5]
print("list1[0]:",list1[0])
print("list2[1:4]:",list2[1:4])

list = ['中国','美国',1997,2000];
print("\n更新列表\nValue available at index 2:")
print(list[2])
list[2] = 2001
print("New value available at index2:")
print(list[2])

print("\n删除列表元素（del方法）")
print(list1)
del list1[2]
print("删除第3个元素后：")
print(list1)

print("\n删除列表元素（remove）")
list1 = ['中国','美国',1997,2000];
list1.remove(1997)
list1.remove('美国')
print(list1)

print("\n删除列表元素（pop）")
list1 = ['中国','美国',1997,2000];
list1.pop(2)  #删除位置2元素
list1.pop()  #删除最后一个元素
print(list1)


print("\n添加元素")
list1 = ['中国','美国',1997,2000];
list1 .append(2003)
print(list1)

多维列表

#多维列表
rows = 3
cols = 6
matrix = [[0 for col in range(cols)]for row in range(rows)] # 列表生成式
for i in range(rows):
    for j in range(cols):
        matrix[i][j] = i*3+j
        print(matrix[i][j],end=",")
    print('\n')

元组

#元组

tup1 = () #创建空元组
tup2 = (1,2,3,4,5)
tup3 = "a","b","c","d"

#访问元组
print("tup2[0]:",tup2[0])
print("tup2[1:3]:",tup2[1:3])
print(tup3[2:])
print(tup3 * 2)

#元组连接
tup4 = tup2 + tup3
print("连接tup2、tup3：",tup4)

#删除元组
del tup4
#print(tup4)

#元组内置函数
print("\n内置函数：")
tup5 = (12,23,34,9)
y = min(tup5)
print(y)

tup = (1,2,3,4,5)
list1 = list(tup)
print(list1)



#一次性对多个变量赋值
(m,n,q) = (1,2,3) #或m,n,q = 1,2,3
print(m,n,q)

#交换m、n
m,n = n,m
print(m,n)

字典

#字典

#创建
dict1 = {'name':'box','num':2333,'name':'box2'}
print("dict1['name']:",dict1['name'])

#修改
dict1['num'] = 3444 #修改
dict1['sex'] = 0 #新增

#删除
del dict1['name'] #删除键是'name'的所有元素（条目）
dict1.clear() #清空字典里所有元素
del dict1 #删除字典

#in运算（只用于判断某键是否在字典里，功能与has_key(key)相似
dict = {'name':'dog','color':'blue'}
print('name' in dict)

#获取所有值
print(dict.values())

#items()方法 把字典中每对键和值组成一个元组，并把这些元组放在列表中返回
for key,value in dict.items():
    print(key,value)

集合

#集合

#创建
#可以使用{}或set()创建，空集合必须用set()，因为{}是用来创建一个空字典
stu = {'amy','bob','tom'}
print(stu)

#成员测试
if('rose' in stu):
    print('rose在集合中')
else:
    print('rose不在集合中')

#集合运算
#set可以进行集合运算
a = set('abcd')
b = set('cdef')
print("a和b的差集:",a-b)
print("a和b的并集:",a|b)
print("a和b的交集:",a&b)
print("a和b中部同时存在的元素:",a^b)

for循环

#for循环
fruits = ['apple','aa4a','banana','mango']
for fruit2 in fruits:
    print('元素:',fruit2)
print("\n")

for _etter in 'python3.5':
    print('字母:',_etter)
print("\n")

sum = 0
for x in range(1,11):  #range(1,11)生成1~10的整数序列
#或 for x in [1,2,3,4,5,6,7,8,9,10]
    sum = sum + x
print('\n1累加10：',sum)

#通过索引循环
for i in range(len(fruits)): #len()返回列表的长度，即元素个数
    print('当前水果:',fruits[i])
print("循环结束")

函数

#函数
  #随机数
import random
x = random.randrange(6) #从0到5中随机挑选一个整数，不包括数字6
y = random.randrange(2,6) #从2到6中随机挑选一个整数，不包括数字6

# 求最值
a = []
for i in range(1,5):
    z = random.randrange(100,201)
    print(z,end = " - ")
    a.append(z)
print('最大数:',max(a))

#函数
  #求绝对值 abs(式子)

游戏-猜单词

#游戏-猜单词
import random
WORDS = ("python","jumble","easy","difficult","answer","continue","phone","postion","game")
print("""
      欢迎来到猜单词环节
      假装这是一个游戏
      把字母组合成正确的单词
      冲吧
      """)
iscontinue = "y"
while iscontinue == "y" or iscontinue == "Y":
    word = random.choice(WORDS) # 从WORDS中随机挑选一个
    correct = word
    jumble = ""
    while word:  #word不是空串时循环
        position = random.randrange(len(word)) #random.randrange从给定的范围返回随机项
        jumble += word[position]
        word = word[:position] + word[position+1:]
    print("乱序后的单词:",jumble)
    guess = input("\n请你猜：")
    while guess != correct and guess != "":
        print("哦 我没生气")
        guess = input("系统提示：请继续猜")
    if guess == correct:
        print("你真棒")
    iscontinue = input("\n\n继续否？(Y/N):")

参数

# 参数
def d(a='hello',b='box'):
      print(a+b)

d()
d(a='hi')
d('lueluelue')
print('————————————')
#任意个参数
  ## *
def d2(name,*nickName):
    print('全名：%s'%name)
    for nickname in nickName:
        print('小名：',nickname)
d2('大盒')
d2('大盒','小盒')
d2('大盒','小盒','小小盒')
print('————————————')

  ## **
def d3(**p):
    for item in p.items():
        print(item)
d3(x=1,y=2,z=3)

def d4(*p):
    for item in p:
        print(item,end="")
d4(1,2,3)

闭包

#闭包
def a():
  def b(x,y):
    return x+y
  return b

f = a()
print(f(1,2))

递归 汉诺塔问题

#递归 汉诺塔问题
def move(source,target):
    print(source,"==>",target)
def hanoi(n,source,temp,target):
    if(n==1):
        move(source,target)
    else:
        hanoi(n-1,source,target,temp)
        move(source,target)
        hanoi(n-1,temp,source,target)

n = int(input("输入盘子数："))
print("移动",n,"个盘子的步骤是：")
hanoi(n,'A','B','C')

扑克牌发牌程序

#扑克牌发牌程序
import random
n = 52
def gen_pocker(n):  #交换牌的顺序100次，达到洗牌的目的
    x = 100
    while(x>0):
        x = x-1
        p1 = random.randint(0,n-1)
        p2 = random.randint(0,n-1)
        t = pocker[p1]
        pocker[p1] = pocker[p2]
        pocker[p2] = t
    return pocker

def getColor(x):  #获取牌的花色
    color = ["草花","方块","红桃","黑桃"]
    c = int(x/13)
    if c<0 or c>=4:
        return "ERROR!"
    return color[c]

def getValue(x):  #获取牌的牌面大小
    value = x % 13
    if value == 0:
        return 'A'
    elif value >= 1 and value <=9:
        return str(value + 1)
    elif value == 10:
        return 'J'
    elif value == 11:
        return 'Q'
    elif value == 12:
        return 'K'

def getPuk(x):
    return getColor(x) + getValue(x)

#主程序
(a,b,c,d) = ([],[],[],[])  #a,b,c,d四个列表分别存储4个人的牌
pocker = [i for i in range(n)]  #未洗牌之前
pocker = gen_pocker(n)  #洗牌
print("洗牌后：\n",pocker)
for x in range(13):  #发牌，每人13张牌 ##[0,13)
    m = x*4
    a.append(getPuk(pocker[m]))  ##append() 方法用于在列表末尾添加新的对象
    b.append(getPuk(pocker[m+1]))
    c.append(getPuk(pocker[m+2]))
    d.append(getPuk(pocker[m+3]))
a.sort()  #牌手的牌排序，就是相当于理牌，同花色在一起
b.sort()  ##sort() 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。
c.sort()
d.sort()
print("牌手1",end="：")
for x in a:
    print(x,end="")
print()
print("牌手2",end="：")
for x in b:
    print(x,end="")
print()
print("牌手3",end="：")
for x in c:
    print(x,end="")
print()
print("牌手4",end="：")
for x in d:
    print(x,end="")

读文件的三种方式

#读文件的三种方式
File1 = open("d:\\1.txt")
fileContent1 = File1.read()
File1.close()
print("第一种读法：\n",fileContent1,"\n\n第二种读法：")

File2 = open("d:\\1.txt")
fileContent2 = ""
while True:
    fragment = File2.read(3)
    print("-读取-")  #这一步为了判断read调用次数
    if fragment == "":
        break
    print("fileContent2：",fileContent2)  #这一步是为了理解下一句
    fileContent2 += fragment
File2.close()
print('最终结果：\n',fileContent2)

File3 = open("d:\\1.txt")
fileContent3 = ""
while True:
    line = File3.readline()
    if line=="":  #或者 if not line
        break
    fileContent3 += line
File3.close()
print("\n第三种读法：\n",end = fileContent3)

关闭文件

#关闭文件
  ##方法一：try/finally
File = open("d:\\2.txt","w")
try:
    File.write("lueluelue")
finally:
    File.close()

  ##方法二：with
with open("d:\\2.txt") as File2:
    s = File2.read()
print(s)

文件夹操作

#文件夹操作。均可直接在Shell里运行
import os
os.makedirs("d:\\20190321\\P101")  #创建新目录
os.makedirs("d:\\20190321\\注定会被删除") 
os.rmdir("d:\\20190321\\注定会被删除")   #删除（它只能删除空文件夹）
os.path.exists("d:\\20190321\\注定会被删除")  #判断文件夹是否存在
os.listdir("d:\\20190321")  #列出文件名及文件夹名的字符串列表
os.chdir("d:\\20190321")  #更改当前工作目录
os.listdir(".")

'''
glob()查找匹配文件或文件夹
* 匹配任意个任意字符
？ 匹配单个任意字符
[字符列表] 匹配字符列表中的任一个字符
[!字符列表] 匹配除列表外的其他字符
'''
import glob
glob.glob("[!abcd]*") #查找不以abcd中任一字符开头的文件或文件夹

文件操作1

#文件操作
'''
os.path.dirname(path) 返回path参数中的路径名称字符串
os.path.basename(path) 返回path参数中的文件名
os.path.split(path) 返回path参数中的路径名称和文件名组成的字符串元组
'''
import os
FilePath = "d:\\20190321"
os.path.dirname(FilePath)
os.path.basename(FilePath)
os.path.split(FilePath)
FilePath.split(os.path.sep)

#这是应该在Shell直接运行的，在py里运行，会操作，但是Shell不会显示

'''
os.path.exists(path)  判断参数path的文件或文件夹是否存在
os.path.isfile(path)  判断参数path存在且是一个文件，true false
os.path.isdir(path)  判断参数path存在且是一个文件夹，true false
'''

#统计文件夹下所有文件的大小
totalSize = 0
os.chdir("d:\\20190321")
for fileName in os.listdir(os.getcwd()):
    totalSize += os.path.getsize(fileName)
print( totalSize)

文件操作2

'''
重命名文件  os.rename(,)
复制文件和文件-shutil
shutil.copy(source,destination)  复制文件
destination可以是文件夹，表示将文件复制到新文件夹里。
           也可以是包含新文件名的路径，表示复制的同时将文件重命名
shutil.copytree(source,destination)  复制整个文件夹，包括其中的文件及子文件夹
'''
#复制
import shutil
import os
shutil.copytree("D:\\20190321\\P101","D:\\20190321\\P101-backup")
for fileName in os.listdir("D:\\20190321\\P101"):
    print(fileName)

print("------")
#移动和改名
"""
shutil.move(source,destination)与shutil.copy()相似，
destination既可以是一个包含新文件名的路径，也可以仅包含文件夹
如果destination中指定的新文件名与文件夹中已有文件重名，则会覆盖
"""
#删除
"""
os.remove(path)
os.unlink(path)

os.rmdir(path)只能删除空文件夹
shutil.rmtree(path)删除整个文件夹，包括所有文件及子文件夹

以上删除均不可恢复
"""
#遍历目录树-处理文件夹中包括子文件夹内的所有文件-来自P105
  ##这个的for有点意思
list_dirs = os.walk("D:\20190321") #返回一个元组
    ###1.为什么这里路径一个两个斜杠都可以，但是别的情况不行 2.这里把路径换成表格也不行
print(list(list_dirs))
print("+++")
for folderName,subFolders,fileNames in list_dirs:
    ###不明白为什么不进入循环
    print("进入循环1")
    print("当前目录：" + folderName)
    for subFolder in subFolders:
        print("进入循环2")
        print(folderName +"的子目录" + "是--" + subFolder)
        for fileName in fileNames:
            print(subFolder +"的文件" + "是--" + fileName)

实例属性和类属性

#实例属性和类属性
class Person:
    num = 1   #类属性
    def __init__(self,str,n):  #构造函数
        self.name = str   #实例属性
        self.age = n
    def SayHello(self):   #成员函数
        print("Hello!")
    def PrintName(self):
        print("姓名:",self.name,"年龄：",self.age)
    def PrintNum(self):
        print(Person.num)   #由于是类属性，所以不写self.num

P1 = Person("木木子",42)
P2 = Person("小小茂",36)
P1.PrintName()
P2.PrintName()
Person.num = 2   #修改类属性
P1.PrintNum()
P2.PrintNum()

types.MethodType

#types.MethodType
import types
class Student(object):
    pass
def set_name(self,name):
    self.name = name
def set_age(self,age):
    self.age = age
def set_sc(self,x,y):
    self.x = x
    self.y = y

    
x1 = Student() #类的实例化
x2 = Student()
x1.set_age = types.MethodType(set_age,x1) #实例绑定一个方法
x2.set_age = types.MethodType(set_age,x2)
Student.setsc = types.MethodType(set_sc,Student) #另一种绑定
Student.set_name = types.MethodType(set_name,Student) #给此类绑定一个方法
x1.set_age(12) #初始化
x2.set_age(13)
x1.setsc("xmc","xu")
Student.set_name("hhh")
print(x1.age) #12
print(x2.age) #13
print(x1.x,x1.y) #xmc xu
print(x1.name) #hhh
print(x2.name) #hhh

继承_super()

class FooParent(object):
    def __init__(self):
        self.parent = 'I\'m the parent.'
        print ('Parent')
    
    def bar(self,message):
        print ("%s from Parent" % message)
 
class FooChild(FooParent):
    def __init__(self):
        # super(FooChild,self) 首先找到 FooChild 的父类（就是类 FooParent），然后把类B的对象 FooChild 转换为类 FooParent 的对象
        super(FooChild,self).__init__()    
        print ('Child')
        
    def bar(self,message):
        super(FooChild, self).bar(message)
        print ('Child bar fuction')
        print (self.parent)
 
if __name__ == '__main__':
    fooChild = FooChild()
    fooChild.bar('HelloWorld')

继承2

#继承
import types
class Person(object):
    def __init__(self,name = '',age = 20,sex = 'man'):
        self.setName(name)
        self.setAge(age)
        self.setSex(sex)
    def setName(self,name):
        if type(name) != str:
            print('姓名必须是字符串')
            return
        self.__name = name
    def setAge(self,age):
        if type(age) != int:
            print('年龄必须是整型.')
            return
        self.__age = age
    def setSex(self,sex):
        if sex != '男' and sex != '女':
            print("性别输入错误")
            return
        self.__sex = sex
    def show(self):
        print('姓名：',self.__name,'年龄：',self.__age,'性别:',self.__sex)
class Student(Person):
    def __init__(self,name = '',age = 20,sex = 'man',schoolyear = 2016):
        super(Student,self).__init__(name,age,sex)
        #或 Person.__init__(self,name,age,sex)
        self.setSchoolyear(schoolyear)
    def setSchoolyear(self,schoolyear):
        self.__schoolyear = schoolyear
    def show(self):
        Person.show(self)
        #或 super(Student,self).show()
        print('入学年份:',self.__schoolyear)

if __name__ == '__main__':
    zhangsan = Person('张三',19,'男')
    zhangsan.show()
    lisi = Student('李四',18,'男',2015)
    lisi.show()
    lisi.setAge(20)
    lisi.show()

运算符重载

#运算符重载
class Vector:
    def __init__(self,a,b):
        self.a = a
        self.b = b
    def __str__(self):
        return 'Vector(%d,%d)' % (self.a,self.b)
    def __add__(self,other):
        return Vector(self.a + other.a,self.b + other.b)
    def __sub__(self,other):
        return Vector(self.a - other.a,self.b - other.b)

v1 = Vector(2,1)
v2 = Vector(-1,0)
print(v1 + v2)
print(v1 - v2)
print(v1 * v2)

读取数据库内容1

# 读取数据库内容
import sqlite3
# 打开数据库
conn = sqlite3.connect("数据库的地址.sqlite3")
# 使用游标查询数据库
cursor=conn.cursor()
# 执行sql语句
cursor.execute("select * from 表单的名称")
for x in cursor:
    for i in range(len(x)):
        print(x[i])
    print("\n")
cursor.close()
conn.close()

读取数据库内容2

import sqlite3


def sql_to_text(f_ming,n_row):
    f_ming = open('明文.txt', 'w')
    n_row = 0
    conn = sqlite3.connect("数据库的地址.sqlite3")
    # 使用游标查询数据库
    cursor = conn.cursor()
    # 执行sql语句
    cursor.execute("select * from 表的名称")
    for x in cursor:
        f_ming.writelines(str(x))
        f_ming.write("\n")
        n_row = n_row+1

    print("n_row = ",n_row)
    f_ming.close()
    cursor.close()
    conn.close()

def text_to_sql(n_row):
    h = 0
    rows = 16
    cols = 7
    middle = [[0 for col in range(cols)]for row in range(rows)]
    f_mi = open('名称.txt', 'rb')
    conn = sqlite3.connect("数据库的地址.sqlite3")
    # 使用游标查询数据库
    cursor = conn.cursor()
    print("TXT转SQL")
    #cursor.execute()
    i=0
    for line in f_mi.readlines():
        print("i=",i)
        i = i+1
        print(line)
        cursor.execute("insert into 表单名称 values(?,?)",(i,line))
    conn.commit()
    f_mi.close()
    cursor.close()
    conn.close()
def str_to_other(line,middle):
    """从line[1]开始
    h=0
    j=0
    i=0
    while line[i+1]!="\n": #判断不在末尾
         while line[i+1]!="," or line[i+1]!=")":# 判断这节字符是否结束
             middle[h][j] = line[i]
             j++
             i++
        middle[h][j] = "\n'
        h++
    return h
    """
    h=0
    j=0
    i=0
    while line[i+1]!="\n": #判断不在末尾
         while line[i+1]!="," or line[i+1]!=")":# 判断这节字符是否结束
             middle[h][j] = line[i]
             j = j+1
             i = i+1
         middle[h][j] = "\n"
         print(middle[h])
         h = h+1
         i = i+1
    return h

if __name__ == '__main__':
    f_ming = open('明文.txt', 'w')
  #  f_mi = open('明文.txt', 'r')
    f_jie = open('解密文.txt', 'w')
    n_row = 16
  #  sql_to_text(f_ming,n_row)
    text_to_sql(n_row)

结语（小小声的废话）

我学Python用的是《Python程序设计——从基础到开发》这本书，以自学为主，自学方式是敲书上的代码和做思维导图笔记，大部分代码块来自那本书，学习笔记全来自那本书。

（其实我觉得看会了书本和笔记倒是次要的，如何拄着“代码块”小心翼翼地走上几步反而是很实际的上手方式。）

其实有C的基础，自学起来不算太难。当然，一本书的量我也编不出特别复杂的东西哈哈哈哈。而且……两三个月不动手，我感觉自己几乎忘完了哈哈哈。当时是以编写某个程序为导向而学习，所以有些细枝末节的疑问因时间紧迫未做处理。

老师们很重要，不论是打语言基础的还是点拨的老师！学海无涯，没有指导和交流，我们就容易失去信心、迷失方向、费尽心力还跑圈圈路……

感谢大家！！！

希望这份笔记能帮到有缘人8。