我是如何在四天内搞定Python基础的

1、这是一篇认真严肃的学习经验帖！！！

2、推荐图书：跟老齐学python轻松入门（3.0）+笨方法学python【自己把握一下这本书上个别地方的代码是否需要修改，或因版本问题，2.0版本和3.0版本有些地方不一样】，个人经验是一天看几章跟着老齐学python，然后再敲几十道笨方法学python里面的练习辅助，代码练习进度一定要跟上看书进度，敲完代码再继续回过头看书复习一遍再学习新章节，最后学完重新看一遍审视一下那些知识点，学习效率和学习质量都会非常的高，一周搞定python基础绰绰有余。当然，如果毫无编程基础，可以看得稍微慢一点。

3、环境配置较为简单，请自行参考跟老齐学Python或者搜索网上解决方案，我现在用的还是windows系统，一般我常用cmd或者eclipse+pydev来运行。如果还未学习的同学，建议按照推荐方法尝试一下，请学完基础再来看这篇帖温习，以下为基础知识笔记，部分地方只点到为止，码字不易！

4、天朝学习者请注意在首行输入#coding:uttf-8，这里只提供一种写法，足矣。单行注释 #   ，多行注释 '''...'''。

5、创建一个.py文件，即称为一个模块，模块里面可以写class类【3.0版本默认继承了Object不需要写】和def函数，模块一般要放在包里面，包即为一个文件夹，请注意包里要包含__init__.py（空文件，不需要有内容，以确保该包其他模块可以被引用），其中，类名各单词首字母大写连接，函数名或者方法名均小写且单词之间一根下划线连接。其中，以下举例大部分只采用模块来介绍。

6、学习前了解几个方法：help(函数名)【查看函数文档】，id(object)【读取对象的内存地址】，type(object)【查看对象的数据类型】，dir(obj)【遍历对象方法】。

7、python可以自动处理大整数类型，浮点数则存在上限和下限，超出范围则溢出。

8、牢记：对象有类型，变量无类型，变量只是被贴上了对象的标签。

9、求商a//b，引入模块解决除法：

​
import decimal
a=decimal.Decimal("10.0")
b=decimal.Decimal("3")
print(a/b)#3.333333333333333333333333333

from fractions import Fraction
print(Fraction(10,3))#10/3

​

10、余数a%b，或者返回商和余数divmod(a,b)-->(div,mod)

11、四舍五入round函数，如：round(1.2345,2)-->1.23

12、会使用科学计数法e,**和math标准库中的pow作用一样，了解其他math里的函数

13、运算优先级与其他语言类似，只是and,or,not x,in,not in【是不是其中一个成员】,is,is not【比较两个对象是否为同一个】这些是英文而不是符号。

14、使用“+”使两个字符串连接起来，但是连接对象必须是同一个种类型，当然，同为数字则求和，否则即进行类型转换

15、转义字符常见【\,\',\",\a响铃,\b退格,\e转义,\000,\n,\v纵向制表符,\t横向,\r回车,\f换页,\o八进制,\x十六进制】

16、键盘输入可以使用方法input,raw_input，如：age=raw_input("请输入你的年龄：")

17、python中字符串支持索引和切片，可以根据下标找到元素，也可以根据元素读第一个下标，如：

my_str="welcome123ss"
print(my_str[0])#w
print(my_str.index('w'))#0
print(my_str[1:])#得到从一号到最后的字符串
print(my_str[:])#得到所有
print(my_str[:10])#从开始到九号字符
print(my_str[2:5])#lco

同时，字符串还支持len(str)字符串长度,+连接字符串,*重复字符串,in判断是否包含某字符串,max(str)最大,min(str)最小等方法。字符串输出格式有"%s" % str或者"{0}".format(str).format依然可以采取切片的方式输出字符串，但是它还有左右中以及花样修改数字格式的写法。如：{1:>15}右对齐{0:^15}居中{1:6.2f}第二个位置的长度是六个字符且保留两位小数，{0,4d}第一个位置的长度是四个字符，{0:04d}位数不足补0.其实还可以：isalpha()字符串全是字母、split()按字符拆开称为列表、strip()两头去空、lstrip()左去空、rstrip()右去空、upper()大写、lower()小写、join()按字符将列表分隔但是·字符串不支持修改。

18、列表用[ ]表示，s=[1,2,3,"abc",[1,3,4]]，type为list，可存放不同对象，甚至列表存列表，对于序列切片的完整写法是seq[start:end:step]，其中step的值为正，从list左边看，负数从-1开始，从list右边看，通过list[ : :-1]即可实现列表反转。列表基本操作有len()、+、*、in、max()、min()，还有几个常用方法如：append()追加到list最后、extend()两列表合并【必须可迭代hasattr才能使用此方法】、count()元素重复出现次数、index()、insert(i:x)追加到list任意位置、remove()正确删除，删除找到符合条件的第一个，找不到就报错，原地修改无返回值、pop(i)删除该索引的元素且作为返回值，默认删除最后一个、reverse()列表倒序、sort()排序,数字默认升序，参数为true升序，字符串按长度。

19、元组tuple，t=1,"2",[1,3,4],(123,"learn") 圆括号括起来【可以不用】，元素之间是有逗号隔开，如果只有一个元素，依然要加逗号，元素任意类型。所有在列表中修改列表的方法，在元组中都失效，元组操作速度快于列表【遍历】，元组可以在字典中用作key，列表不可以，元组本身不可变而列表可以。

20、字典dict,键值对,三种方法创建,如：

#空字典
mydict={}
#利用元组
name=(["XXX","XXX"],["XX","XX"])
mydict=dict(name)
#利用fromkeys()
mydict={}.fromkeys("xx键","xx值")#有多个用括号分别把键或者值括起来

可以通过键找到值，基本操作有：len(d)长度、d[key]找值、d[key]=value赋、del d[key]删除键值对、d2=d1.copy()、d.clear()清空、d.get(key)返回值没有也不报错、d.get(k,v)返回值没有返回后面这个vaule、d.get(key)返回值、d.setdefault()返回值不在则添加键值对、dict.item/keys/values()得到键值对、键或者值的set、pop(key/key,value)删除键值对，没有就报错、popitem()随机删除、d1.update(d2)更新，这里将d2纳入了d1

21、集合set，s1=set()【创建空集合只能使用这种方法】或者s1={"abc",123,{"name":"lp"}}元素不可重复，可以作为一种高效元素去重方式，无顺序，不支持索引,主要方法：add添加元素、update添加集合、pop、remove删除指定元素，不存在报错、discard删除指定元素，不存在不报错、clear清除、并集 |、子集>或者<、交集&、差，补 -

22、布尔bool and or not,复杂表达式最好使用括号。

23、引入模块5种方法：

import math
math.pow(2,3)

from math import pow
pow(2,3)

from math import pow as name
name(2,3)

from math import *
....

from math import pow,e,pi
...

24、python中两数值对调，只需要a,b=b,a【一一赋值】。a=b=1【链式赋值】。+=【增量赋值】。

25、条件和循环：

#缩进四个空格
if a==8:
    ...

#缩进四个空格
if a==1:
    ...
elif a==2:
    ...
else:
    ...

#缩进四个空格
成立执行 if 条件 else 不成立执行

#缩进四个空格
hello="hello"
for item in hello:
    ...
for i in range(len(hello)):
    ...hello[i]...

#缩进四个空格
while 条件:
    ...
#while...else和for...else跳出循环之后做的事情写在else里面

26、range(start,stop,step)【整数范围】开始、结束、变化的步长【默认为1，不能为0】

27、zip(a,b)内建函数，序列长度不同以短的为基准

a=[1,2,3,4]
b=[9,8,7,6]
d=[]
for x,y in zip(a,b):#zip(a,b)-->[(1,9),(2,8),(3,7),(4,6)]
    d.append(x+y)#d-->[10,10,10,10]

28、同时得到列表索引和元素for (i,ele) in enumerate(list):

29、强大的列表解析squares=[x**2 for x in range(1,10)]  #squares=[1,4,9,16,25,36,49,64,81]

30、break和continue与其他语言一个意思用法

31、文件操作，函数主要有open()【打开已经存在的文件,一个open只能读完一次，a表示允许追加内容，w写会清空再写,r读取，有加号可读写，b二进制】 read()【读取文件内容】 readline() readlines()【返回列表】 write()【写入或追加】 close()【关闭文件，使用with语句不需要close：with open("xx.txt) as f : ....】 stat()【文件状态属性】 seek()【写入或读取指针位置】 fileinput.input()【读取大文件】

#coding:utf-8
'''
@author: 罗飘
'''
from sys import argv
from pip._vendor.distlib.compat import raw_input

script,filename=argv,"a.txt"
txt=open(filename) #打开已经存在的文件
print(txt.read()) #读取内容打印

#print(txt.read()) 直接这样写无效，因为一个open读取以后就标记到了最后，除非再使用一个open

print("Type the filename again:")
file_again=raw_input(">")
txt_again=open(file_again)
print(txt_again.read())

#读写文件
raw_input("?")

print("opening the file...")
target=open(filename,"w") #a.txt，w清空再写入

print("Truncating the file. Goodbye!")
target.truncate()

print("Now I'm going to ask you for three lines.")

line1=raw_input("line1:")
line2=raw_input("line2:")
line3=raw_input("line3:")

print("Now write these to the file")

target.write(line1+"\n")
target.write(line2+"\n")
target.write(line3+"\n")

print("close")
target.close()

#coding:utf-8
'''
@author: 罗飘
'''
from sys import argv
from os.path import exists
from pip._vendor.distlib.compat import raw_input


script,from_file,to_file=argv,"a.txt","b.txt" #a，b两文件均存在，且在当前目录下

print("Copying from %s to %s"%(from_file,to_file))

in_file=open(from_file)
indata=in_file.read()

print("The input file is %d bytes long"% len(indata)) #长度
print("Does the output file exist?%r"% exists(to_file)) #文件是否存在
raw_input() #不需要获取输入，按enter继续进行下一步操作

out_file=open(to_file,"a")
out_file.write(indata) #a表示允许追加内容，w写会清空再写,r读取，有加号可读写，b二进制
print("成功复制")

out_file.close()
in_file.close()

32、所有迭代器对象都有__next__()方法【头尾分别两根下划线】，文件天生可迭代。

33、函数格式：

def 函数名称（参数列表【使用*arg解决参数个数的不确定性，**kargs键值对形式收集数据】）:

'''

函数文档

'''

(缩进4空格)函数体（语句块）

34、嵌套函数想得到执行必须显式调用，且注意如果内嵌函数想使用外包裹函数定义的变量，可以在内嵌函数里把这个变量前面加上nonlocal

der foo():
    a=1
    def bar():
        nonlocal a
        a=a+1
        print("bar()a=",a)
    bar()#显式调用
    print("foo()a=",a)


foo()#2 2

35、闭包：定义在另一个函数里面【内嵌函数】，引用其所在函数环境的自由变量

36、lambda一行解决问题的函数【注意比较map上下、reduce横向，过滤器filter筛选同种类列表的元素使用】，使用的两种方式：

g=lambda x,y:x+y
g(3,4) #7

(lambda x:x**2)(4) #16，返回4的2次方

37、命名空间【本地、全局global是（）、内置】

38、类是对一群具有同样属性和方法的对象的抽象。类的格式：

​
#注意缩进四空格，类名首字母大写
class 类名(父类1,父类2):
    '''
    文档注释
    '''
    
    #属性值
    x=y 
    
    #方法
    def __init__(self):#无返回值，第一个参数必须是self
        ...
        
    def 其他方法(self,*args):#默认使用self为第一个参数，修饰器所修饰的方法则不需要self
        ...

​

39、类属性可以进行增加、删除、修改【类点属性名】

40、类对象和实例对象的区别在于，创建实例对象会检查__init__()方法，如果有则会调用带方法；而且类属性跟类绑定不受实例的影响，但是实例是在类的基础上建立的，所以类属性可以影响实例属性，而当类中变量引用的是可变对象时，类属性和实例属性都能直接修改这个对象，影响另一方的值，如：列表。

41、个人感觉，self的含义类似于java的this

42、通过类获取方法的时候，得到的是非绑定方法对象，通过实例则是绑定对象。

43、与类无关的方法，但两者都有同一个属性，且方法需对属性操作，应使用类方法修饰器来修饰该方法@classmethod，要将类本身传入方法做参数。

class Foo:
    lang="Java"
    ...
    @classmethod
    def get_class_attr(cls):
        return cls.lang
    ...

44、与类无关，同时要被里面的方法调用，为了便于维护，使用静态方法修饰器来修饰该方法@staticmethod

45、python支持单继承和多继承【class SomeClass(FatherClass1,FatherClass2)】，对继承属性和方法的搜索称之为广度优先

46、子类里面有与父类同样的名称和属性，称之为对父类相应部分的重写，重写之后，父类的相应部分不再被继承到子类，没有重写的部分依然被继承。想要调用父类重写部分，可以使用super方法，如：super(子类名,self).重写方法名/属性

47、多态指同一种行为具有不同表现形态和形态的能力。如：

#多态案例：
class Cat:
    def speak(self):
        print("meow")
class Dog:
    def speak(self):
        print("woof")
class Bob:#这不属于宠物
    def speak(self):
        print("hello!")
    def drive(self):
        print("beep beep")
#不检查传入对象的类型
def command(pet):
    pet.speak()

pets=[Cat(),Dog(),Bob()]

for pet in pets:
    command(pet)

48、私有化属性只要在名字前面加上双下划线即可，调用私有属性则需要@property修饰器了，使用以后正常属性一样调用，不需要下划线。如：

class ProtectMe:
    def __init__(self):
        self.me="lp"
        self.__name='notlp'#私有属性
        
    @property
    def name(self):
        return self.__name
    
#执行程序
if __name__=="__main__":
    p=ProtectMe()
    print(p.name())#正常调用私有属性

49、判断对象类型方法isinstance(a,c1)

50、属性拦截方法：

__setattr__(self,name,value)：如果要给name赋值，调用此方法

__getattr__(self,name)：如果name被访问，但它不存在就会调用此方法

__getattribute__(self,name)：无论是否存在，name被访问都会调用此方法

__delattr__(self,name)：如果要删除name，这个方法被调用

51、迭代器hasattr(xxx,'__iter__')，检查是否可迭代，也可以自己写一个迭代器方法

class MyRange:
    def __init__(self,n):
        self.i=1
        self.n=n
    def __iter__(self):
        return self
    def __next__(self):
        if self.i<=self.n:
            i=self.i
            self.i+=1
            return i
        else:
            raise StopIteration()
        
if __name__=="__main__":
    x=MyRange(7)
    print([i for i in x])

52、常见异常：NameError【尝试访问一个没有声明的变量】ZeroDivisionError【除数为0】SyntaxError【语法错误】IndexError【下标越界】KeyError【请求字典中不存在的关键字】IOError【输入输出错误，可能文件不存在等】AttributeError【尝试访问未知的对象属性】

53、处理异常几种方法：try...except...  try...except...*n   try...except(error1 ,error2,...) as e...还可以添加else执行try顺利执行以后的操作和或者添加finally最终无论哪种情况都执行

54、断言assert是一句等价于布尔真的判定，断定什么东西必然是什么，如果不是就抛出异常。

55、学习使用常用标准库，如：OS、堆、日期和时间、XML、JSON等，也要了解第三方库的安装。

56、使用标准库中的shelve模块来进行数据操作：

import shelve

#如果不存在则自动创建文件
s=shelve.open("shelve.db",writeback=True) #添加后面writeback参数为真，可以添加多条数据
s["author"]=['abc']#添加了一个列表类型数据，也可以添加其他类型的
s["author"].append("cba")
s["name"]="lp"
print(s["author"]) #['abc','cba']

# s 相当于一个类字典，遍历
for k,v in s.items(): # name : lp (换行) author : ['abc', 'cba']
    print(k,":",v)

s.close()

57、使用MySql数据库来操作数据，先安装MySql再安装PyMySql【Python操作数据库的模块，手动下载地址：https://github.com/PyMySQL/PyMySQL，解压后，cmd中输入：python setup.py install；如果可以使用pip命令请在联网状态在cmd中输入：pip  install  pymysql】

​
#coding:utf-8
'''
Created on 2018年11月22日

@author:罗飘
'''
import pymysql

#1、连接mysql数据库
conn=pymysql.connect(host='localhost',port=3306,user='root',passwd='admin',db='pySql',charset='utf8')

#2、通过游标执行sql语句，，建立连接以后，通过连接对象建立游标
cur=conn.cursor()
'''
cur=conn.cursor(pymysql.cursors.DictCursor)
可以在连接对象的游标方法中提供一个参数，将读取数据变成字典形式，便可以精确到键去找值
如：
cur.execute("select * from users")
lines=cur.fetchall()
for line in lines:
    print(line["username"])

'''

'''
#3、插入一条数据使用execute()方法，它还可进行删除、修改操作
cur.executemany("insert into users (username,email) values (%s,%s)",(("python1","python1@gmail.com"),("python2","python2@gmail.com"),("python3","python3@gmail.com")))
conn.commit()#最终提交，所以更新操作都要牢记这一点
'''

'''
#4、查询多条，游标会自动下移，这个操作使查询无法再继续使用同一个游标了
cur.execute("select * from users")
lines=cur.fetchall()
for line in lines:
    print(line)
'''


#只查询一条，游标会自动下移
cur.execute("select * from users where id=1")
line=cur.fetchone()
print(line)
#只查询到了一条数据存储在cur，上一个操作使游标已经下移，再次使用打印none
line=cur.fetchone()
print(line)
#绝对移动游标位置，再次打印，打印成功
cur.scroll(0,"absolute") #后面这个参数绝对移动，重新定位到第一条，如果后面没有这个参数则是相对当前游标位置移动
line=cur.fetchone()
print(line)

#不要忘记关闭资源
​cur.close()
conn.close()

58、SQLite小型关系数据库，不需要安装，安装了python即可使用，相当于标准库中的一部分了。除了连接和mysql操作参数不一样，其余操作基本一致，注意数据库批量操作数量也不要太多。

#coding:utf-8
'''
@author: lp
'''
import sqlite3

#如果已经有了test_21数据库就连接它，如果没有就创建了再连接它
conn=sqlite3.connect("test_21.db")

#其余增删查改操作和上面mysql的一致

59、关于MongoDB数据库操作就不介绍啦，反正not only sql 没毛病【其实是因为我没有安装，现在暂时不用它，我懒得装了，磁盘要爆啦！】【补上：https://blog.csdn.net/qq_37575994/article/details/84484782】

       好啦，python基础暂告一段落，python在很多方向表现活跃，比如web开发、运维、自动化测试、数据分析、人工智能等，感兴趣的同学都可以学一学啦！我准备补完javaweb基础的博客就开始学习python开发网站的优秀框架Django啦，期待自己的第一个python网站！大三狗要开始加油了！