python从入门到精通

 计算机组成原理：

 存储器对比：

磁盘：永久存储数据，每秒读取几百几千。

内存：容量大，每秒读取数百万到数千万之间。

寄存器：CPU内部最快的存储器，读取速度是其他存储器的数百倍，每秒数十亿到百亿。但是大小有限，只能存储极少量数据，

编程语言的发展历程：

机器语言：二进制（0和1）编写程序，难以记忆、理解、维护。

汇编语言：用符号代替二进制（如A代表10）为指令。

高级语言：用语句替代指令（封装），一条语句包括多条指令（多个二进制）。例如C语言、C++、java、python、javascript。

语言越方便，运行速度越慢。

编译性语言和解释性语言：

编译性语言：C、C++、go等

解释性语言：python、php、Javascript等

混合型：java等

编译性语言 优点：一次性编译为平台相关的机器语言文件，运行时脱离开发环境，运行快。

                   缺点：与特定平台相关，一般无法移植到其他平台。

解释性语言 优点：只要平台提供相应的代码解释器就可以运行，方便源程序移植。

                   缺点：每次需将源代码转换成机器语言执行，效率低。

python环境安装：

安装链接http://python.orgDownloads--Windows--选择3.6+版本（一般最新版本）--下载完后选择自定义安装（customize installation）然后勾选add python.exe to PATH--其他默认。

打开终端：windows键+R，然后输入cmd。

dir：展示当前所有文件夹。

cd 文件夹名：打开该文件夹。

cd..：回到上一次路径。也可以直接把..换成路径，跳转到该路径下。

换盘查找：先输入 D 回车。

exit（）：退出

pycharm下载：

下载https://www.jetbrains.com/pycharm/download/?section=windows#section=windows

python应用领域：

          web开发、网络编程、爬虫、云计算、人工智能数据分析、自动化运维、金融分析、科学运算、游戏开发。 

python语法：

          pycharm的格式化快捷键：ctrl+alt+L

          变量名只能有字母、数字、下划线-,开头不能是数字

print（f"我的名字叫{name}，我的年龄是{age}，我的身高是{height}"）

        f代表格式化

字符串的索引、切片、拼接、

lens：字符个数，一个英文字符1个字节，一个中文字符3个字节

输入函数;input（） name=input("请输入您的名字")

数字字符串转数组：int（数字字符串名字）

s1.upper（）           s1里面全部转大写        lower转小写

是否以什么开头  s1.startswith("什么")        结尾：endswith

是否纯数字字符串        s1.isdight（）

去掉空格两端的空格与换行符        s1.strip()

把一个字符串按照什么切割为列表：s1.split（"什么"）

把什么加到字符串串起来形成列表："什么".join(字符串名)

寻找：s.find("寻找的东西")        没有找到返回-1        index没有找到则会报错

计数：s1.count（“张三”）

替换：s1.replace("替换前字符","替换后字符")        生成新值，不是修改原值

自加：a+=2        a=a+2

列表增加：names.append("A")

插入：names.insert(2,"年龄"）

合并两个列表：n1.extend(n2)

列表中嵌套一个小列表：names.insert(2,[1,2,3])

del直接删:del names[2]

pop()删除：names.pop(要删除的位置)

修改：name[0]=1        直接改

查找：name.index("找的东西")

切片：names[start:end:步长]                从左到右，取头不取尾

从小到大排序：names.sort()        大到小:reverse

列表循环：for i in names        print(i)

字典：{key1：value1，key2：value2}

增加：names["key"]=[value]

删除：names.pop("key名字")        del.names["key名字"]        names.clear()清空字典

修改：dic['key']='new-value'

查：dic['key']        返回字典中key对应值

       dic.keys()        返回包含字典所有key的列表

       dic.values()         返回包含字典所有value的列表

       dic.items（）        返回一个包含所有元组的列表

循环：for k in info        print（k，info[k]）

求长度：len（info）

python文件：

打开文件：f=open("文件名"，mode=" ") mode为r（只读模式），w（创建模式），a（追加模式）

 r+（可读可写）mode可不写

写文件：f.write("内容")

读文件：print(f.read())        读一行：print(f.readline())

保存并关闭：f.close（）

文件循环：for line in f： line=line.split()        (分离为列表)        print(line)

如何处理图片，视频：二进制模式

rb：二进制只读模式        wb：二进制创建模式        ab：二进制追加模式

f=open（"gbl-file2","wb"）

f.write("哈".encode("gbk"))        写入文本要用字节类型

移动光标：f.seek()          UTF8：一个中文3字节        gbk：一个中文2字节

返回光标：f,tell()

修改文件：

打开文件：f.open("文件名","r+")

加载到内存：data=f.read()

                      new-datadata.replace("修改前文字","修改后文字")

                      print(new-data)

清空文件：f.seek(0)

                  f.truncate()

把新内容写会硬盘：f.write（new-data）

                                f.close()

用户登录认证程序：

#把账号读到内存，为了方便调用，换成list结构

f=open（"accont.db","r"）
for line in f:
    line=line.strip().split(",")
    accounts[line[0]]=line
print(accounts)

#验证


while true:
    user=input("username:").strip()
    if user not in acounts:
        print("该用户未注册")
        continue
    elif:account[user][2]=="1":
         print("此账户已锁定，请联系管理员")
        continue

count=0
while count<3:
    password=input("password:").strip()
    if password==accounts[user][1]:
        print(f"welcome{user}登录成功"）
        exit()
    else:
        print("password error")

count+=1

if count==3:
    print(f"输错了{count}密码，需要锁定{user}")

#先改内存信息里的账号状态
#把dict数据转换为原account.db数据格式，存回原文件

account[user][2]='1'
f2=open.("account.db","w")
for user, val in account.items():
    line=",".join(val)+"\n"
    f2.write(line)
f2.close()

exit()

def calc(x,y)

      res=x**y

      print（res）

c=clac(a,b)

print(c)

xy为形参，ab为实参

print(abs(-10))        abs取绝对值

print（locals（））        打印程序所有变量名

迭代器：map

l=list(range(10))       

def calc(x):

        return x**2

m=map(calc,l)

for i in m:

print(i)

最大值：max

l=list(range(10））
print(max(l))

求和：sum

print（sum（l））

保留小数：print（round（3.1415926,2））        结果为3.14

把一个东西变字符串：print（str（list（range（10））））

看字符类型：print（type(a)）

zip:拉链

a=['1','2','3']        b=['一','二','三','四']

for i in zip(a,b):        print(i)

结果（'1','一'）（'2','二'）('3','三'）

filter:把列表每一个元素交给第一个变量,如果为真则返回该值

l=list（range（10））
def compare（x）
if x>5:
    return x
for i in fliter(compare,l):
    print(i)
#结果为6789

学籍注册小程序：

#数据存到文件里的格式 姓名，年龄，手机，身份证，学科
#确保手机，身份证在文件里只有一条
#选学科时列出选项，给用户选择
db_file="student_data.db"

def validate_phone(num)
    if not num.isdight():
        exit("手机号必须是数字")
    if len(num)!=11:
        exit("手机号必须是11位")

    return True

def register_api():

    stu_data={}    #为了存后面学员数据
    print("欢迎".center(50,"-"))
    print("请完成学籍注册")
    name=input("姓名:").strip()
    age=input("年龄:").strip()
    phone=input("手机号:").strip()
    if phone in phone_list:
        exit("该手机号已注册")
    validate_phone(num)    #引用函数
    id_num=input("身份证:").strip()
    if id_num in id_num_list:
        exit("该身份证号已注册")

    course_list=["python开发","linux云计算"，"网络安全","人工智能","前端开发"]
    for index,crouse in enumerate(course_list):
         print(f"{index}.{course}")

    #enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时        
    列出数据和数据下标，一般用在 for 循环当中。

    selected_course=input("请选择想学的课:")
    if selected_course.isdight():
        selected_course=int(selected_course)
        if selected_course>=0 and selected_course<len(course_list):#合法选项
            picked_course=course_list[selected_course]
        else:
            exit（"不合理选项"）
    else:
        exit("非法输入"）

    stu_data["name"]=name
    stu_data["age"]=age
    stu_data["phone"]=phone
    stu_data["id_num"]=id_num
    stu_data["course"]=picked_course

    return stu_data

def commit_to_db(filename,stu_data):

    f=open(filename,"a")
    row=f"{stu_data["name"]},{stu_data["age"]}{stu_data["phone"]}{stu_data["id_num"]}    
        {stu_data["course"]}"\n"
    f.write(row)
    f.close()
    
def load_validataed_data(filename):

    f=open(filename)
    phone_list=[]
    id_num=[]
    for line in f:
        line=line.split(",")
        phone=line[2]
        id_num=line[3]
        phone_list.append(phone)
        id_num.append(id_num)

    return phone_list,id_num_list

    phone_list,id_num_list=load_validataed_data(db_file)

    student_data=register_api()
    print(student_data)
    commit_to_db(db_file,student_data)

模块：

import module_a #导⼊
from module import xx # 导⼊某个模块下的某个⽅法 or ⼦模块
from module.xx.xx import xx as rename #导⼊后⼀个⽅法后重命令
from module.xx.xx import * #导⼊⼀个模块下的所有⽅法，不建议使⽤
module_a.xxx #调⽤

注意：模块⼀旦被调⽤，即相当于执⾏了另外⼀个py⽂件⾥的代码

模块的查找路径

import sys
print(sys.path)

通过pip安装模块
pip3 install paramiko #paramiko 是模块名

包（package)
若你写的项⽬较复杂，有很多代码⽂件的话，为了⽅便管理，可以⽤包来管理。 ⼀个包其实就是⼀个⽂
件⽬录，你可以把属于同⼀个业务线的代码⽂件都放在同⼀个包⾥。
如何创建⼀个包？

只需要在⽬录下创建⼀个空的 __init__.py ⽂件 ， 这个⽬录就变成了包。这个⽂件叫包的初始化⽂件
，⼀般为空，当然也可以写东⻄，当你调⽤这个包下及其任意⼦包的的任意模块时， 这
个 __init__.py ⽂件都会先执⾏。

以下 有a、b 2个包，a2是a的⼦包，b2是b的⼦包
day6
!"" 课件
 #"" a
 $ #"" __init__.py
 $ !"" a2
 $ #"" __init__.py
 $ #"" a_mod2.py
 $ !"" a_module.py
 #"" b
 $ #"" __init__.py
 $ #"" b2
 $ $ #"" __init__.py
若在a_module.py模块⾥导⼊b2_mod.py的话，怎么办？
a_module.py的⽂件路径为
/Users/alex/Documents/work/PyProjects/py8days_camp/day6/课件/a/a2/a_module.py
想导⼊成功，直接写以下代码就可以
from day6.课件.b.b2 import b2_mod

import os
得到当前⼯作⽬录，即当前Python脚本⼯作的⽬录路径: os.getcwd()
返回指定⽬录下的所有⽂件和⽬录名:os.listdir()
函数⽤来删除⼀个⽂件:os.remove()
删除多个⽬录：os.removedirs（r“c：\python”）
检验给出的路径是否是⼀个⽂件：os.path.isfile()
检验给出的路径是否是⼀个⽬录：os.path.isdir()
检验给出的路径是否真地存:os.path.exists()
获取路径名：os.path.dirname()
获得绝对路径: os.path.abspath() 
获取⽂件名：os.path.basename()
运⾏shell命令: os.system()
重命名：os.rename（old， new）
创建多级⽬录：os.makedirs（r“c：\python\test”）
创建单个⽬录：os.mkdir（“test”）
获取⽂件属性：os.stat（file）

    time.time() ：返回当前时间的时间戳。
    time.localtime([secs]) ：将⼀个时间戳转换为当前时区的struct_time。若secs参数未提供，
则以当前时间为准
    time.strftime(format[, t]) ：把⼀个代表时间的元组或者struct_time（如由
time.localtime()和time.gmtime()返回）转化为格式化的时间字符串。如果t未指定，将传⼊
time.localtime()。
举例： time.strftime(“%Y-%m-%d %X”, time.localtime()) #输出’2017-10-01
12:14:23
    time.strptime(string[, format]) ：把⼀个格式化时间字符串转化为struct_time。实际上它
和strftime()是逆操作。
举例： time.strptime(‘2017-10-3 17:54’,”%Y-%m-%d %H:%M”) #输出
time.struct_time(tm_year=2017, tm_mon=10, tm_mday=3, tm_hour=17, tm_min=54,
tm_sec=0, tm_wday=1, tm_yday=276, tm_isdst=-1)

1. d=datetime.datetime.now() 返回当前的datetime⽇期类型, d.timestamp(),d.today(),
d.year,d.timetuple()等⽅法可以调⽤

2. datetime.date.fromtimestamp(322222) 把⼀个时间戳转为datetime⽇期类型

3. 时间运算
>>> datetime.datetime.now()
datetime.datetime(2017, 10, 1, 12, 53, 11, 821218)
>>> datetime.datetime.now() + datetime.timedelta(4) #当前时间 +4天
datetime.datetime(2017, 10, 5, 12, 53, 35, 276589)
>>> datetime.datetime.now() + datetime.timedelta(hours=4) #当前时间+4⼩时
datetime.datetime(2017, 10, 1, 16, 53, 42, 876275)

4. 时间替换
>>> d.replace(year=2999,month=11,day=30)
datetime.date(2999, 11, 30)

>>> random.randrange(1,10) #返回1-10之间的⼀个随机数，不包括10
>>> random.randint(1,10) #返回1-10之间的⼀个随机数，包括10
>>> random.randrange(0, 100, 2) #随机选取0到100间的偶数
>>> random.random() #返回⼀个随机浮点数
>>> random.choice('abce3#$@1') #返回⼀个给定数据集合中的随机字符
>>> random.sample('abcdefghij',3) #从多个字符中选取特定数量的字符
['a', 'd', 'b']

#⽣成随机字符串
>>> import string
>>> ''.join(random.sample(string.ascii_lowercase + string.digits, 6))
'4fvda1'

#洗牌
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> random.shuffle(a)
>>> a
[3, 0, 7, 2, 1, 6, 5, 8, 9, 4]