我的编程之路，从python重新开始。

大学本科学的计算机科学与技术，十年过去了，现在准备捡起来。目前python跟当前工作有很大帮助，所以从python开始重新走编程之路。

预科：5.28-5.31

一：安装和初学markdown

  • markdown是一款word精华提炼版。常用功能都有，并且更简洁方便。

  • https://www.typora.io下载地址

  • 鼠标选择段落-标题等级

  • 正文格式的基础上，行开头输入一个#加空格，之后输入的内容变为一级标题，两个#变为二级标题。依此类推，一共6个#6级标题。也可以用ctrl+1标记一级标题。

  • 鼠标点选段落，有序标题，会自动缩进。也可以正文格式数字1.加空格开头，自动变为缩进后的有序列表。

  • 按一下回车，自动换行到下一个 。按两下回车，结束当前有序列表。按退格键，删掉数字，之后按Shift+tab键也可以结束当前有序列表的缩进。

  • 再原有缩进基础上，按ctrl+]中括号，可以增加缩进行。

  • 无序列表是不带序号的点点点列表。

  • 加一个红色

  •  

插入图片可以截图直接粘贴，系统自动起名并显示路径，但此路径是本机路径。保存为doc格式时，只是通过路径调用，没存在文件内。需要选文件-导出-PDF，就可以把包括图片在内的内容保存为PDF。

  • 插入：在段落里点选表格

姓名性别爱好年龄
www.baidu.com      
直接输入网址，可以自动变成超链接，超链接鼠标左键点击只提示，按ctrl按左键就可以打开了。      
百度一下 输入中括号再输入小括号，变为超链接加备注，中括号内输入备注，小括号内输入地址。此时的地址，可以为本地地址，也可以时网络地址，网络地址记得加https://     
print（"朱荣升"）
<span style="color:red;">加一个红色</span>

输入三个波浪键点插入代码块。代码块输入后再右下角可以选择编程语言。

二：安装python

百度搜索python。www.python.org

安装多版本，可在每个版本的exe程序重命名加版本号方便区别。

在我的电脑-属性-高级系统设置-环境变量-path-编辑-新增加python安装路径进去，win7系统可能用封号隔开粘贴进去。win10系统直接新建加入路径。

把所有版本的python都配置好，就可以在cmd命令行里直接调用了。

三：安装pycharm

http://www.jetbrains.com/pycharm/

professional是专业版，建议使用但收费。community社区版，免费。

安装过程，选择激活码。

之后粘贴激活码激活

选择上图这里，在右边输入python的安装地址。

目前讲到这里。

pycharm的简单应用

括号，引号等会自动补齐并跳转光标。

shift+回车，完成当前行代码并跳到下一行开头。

end 跳到当前行最末尾

ctrl+d复制粘贴当前行并插入到当前行下一行

ctrl+shift+上下箭头，是上下插入移动当前行。

四：安装git，git对接码云远程代码库

  • https://git-scm.com 下载安装git。

  • 注册码云https://gitee.com ，加入组织，新建仓库，记住用户名密码和仓库的网址。

  • 本地创建一个文件夹作为本地仓库，用来对接网站的远程仓库，在本地仓库空白处右键，选择git bash here。#打开git并进入当前路径。

  • git init #初始化，当前文件目录下会生成一个.git的隐藏文件夹。此文件夹及生成本地仓库并配置完成。

  • git config --global user.email "这里写自己邮箱" 本地git配置邮箱，跟码云无关。

  • git config --global user.name "这里输入名字" 本地git配置用户名，跟码云无关。

  • git add . 这个命令是存档当前对本地仓库文件的增删改操作到本地的git配置记录里。

  • git commit -m "这里写备注信息，随便填" 这个命令是针对刚才的add.的内容放到本地仓库并备注信息。

  • git remote add origin https://gitee.com/old_boy_python_stack_23/19052823038.git 此命令是将本地仓库和后面的网址远程仓库对接在一起。其中remot是命令，origin是自定义的仓库名。

  • git push -u origin master 推送本地仓库内容到远程仓库使两个仓库同步。

  • git pull origin master 从远程仓库拉下来远程仓库的增删改动作。

  • Issues 从组织当中点这个，然后执行。执行完之后在评论区回复完成进度。完成数/总数的形式。哪一题没完成，什么理由写清楚。每天睡觉前把本地写的代码跟码云同步一下。

<div style="text-align: right;"><a name="_label1"></a> <a href="#_labelTop">返回顶部</a></div>
返回顶部

五:思维导图

https://www.processon.com注册。

tab键创建子图，双击写内容，del删除。其他功能慢慢探索。

六:博客园

https://www.cnblogs.com注册，申请开通博客。在选项里选择默认编辑器markdown。markdown里有导出png，然后直接上传，可以减少上传多个图片的问题。

题外话，关于面试：

第一阶段：python基础学习

一:计算机基础知识

  1. cpu 中央处理器,运算速率最快

  2. 内存 临时快速存储，断电即消失，是cpu和硬盘的中介。

  3. 硬盘 长期存储数据，速度相对慢

  4. 操作系统：是一个特殊软件，调配硬件资源来支持其他软件的需求。

二:python的应用和历史

  1. 云计算，web开发，人工智能，系统运维，爬虫，金融辅助，图形gui，游戏。

  2. google，

  3. 3python是一个什么样的语言

    1. 编译型：只翻译一次就到机器语言。C，C++

      • 优点：运行速度快

      • 缺点：开发效率低

    2. 解释型：一句一句的翻译到机器语言。PY，PHP

      • 优点：开发效率高

      • 缺点：运行速度慢

    3. 混合型：Java，C#

  4. 4python的优缺点

    • 可移植性 跨操作系统，跨平台兼容

    • 可扩展性 某一段需要速度快或加密的可以用C来写加进去。

    • 可嵌入性 可以在C或C++里嵌入使其具备脚本功能。

  5. python的种类

    • Cpython 官方版，使用C写的。

    • Jython Java版本

    • IronPython C#实现的

    • PyPy 用python实现python，运行速度快。未来可能爆款

三：python程序

一：写一个python程序

  • 文本文件，保存时，另存为utf-8文件类型。

  • print是排bug神器

    print('hello world')

二：变量，常量，注释，用户交互

  1. 书写格式a = 1

    1. 新建变量a #可以用 a=''来新建一个空的字符串类型的变量。

    2. 把1赋值给变量a

    3. 变量类型由=右边的数据类型决定

  2. 变量命名规则：

    1. 字母_下划线，数字三种组合且不能以数字开头

    2. 不能是python的关键字，例如print，input等等

    3. 不建议用中文和拼音

    4. 可以区分大小写

    5. 要右意义

    6. 驼峰体：AbcDef，下划线分割体：(官方推荐)abc_def

  3. 常量：纯大写字母和下划线组成的，常量也是变量，但通常约定不修改。

  4. 注释

    1. #单行注释 ，每行#后面的内容是为这一行做注释。

    2. 批量注释，选中要注释的大批内容，Ctrl+？键可以批量注释，效果等同于每一行开头加一个#。

    3. 字符串批量伪注释法：用两组三个’‘’单引号‘’‘，或两组三个“”“双引号”“”引起来。这样会使其中的内容变成字符串，如果这个字符串不调用，则会一直闲置，相当于被注释。三个引号有些特殊情况也会用到，注意用这个备注时要注意。

  5. 用户输入input

    • input("这里是提示语可无")

    • import getpass ，输入时不显示 。

    • 在input外面定义类型，无定义时默认是字符串。比如int(input("这里拿到的数据如果可以转换成整形，则转换，如果不能则报错"))

    • print(type(查看这里数据的类型并输出结果))，也可以用type(str)==str来做判断语句。

三：if语句

  1. 书写格式

    if 3>2:
        代码块

     

  1. 单纯选择，条件不满足可跳过

    1. if 条件:

      缩进：成立执行

      不成立跳过

  2. 二选一，必须执行一个

    if 条件:

    缩进：成立执行。

    else ：

    缩进：不成立执行

  3. 多选项可不选，if elif elif 多条件可不执行

  4. 多选项必选其一，if elif elif elif else多选必选一个

  5. 嵌套IF

    1. if条件：

      缩进：上面成立再次if条件：

      再次缩进：上面成立执行

四：字符串格式化输出

  1. 占位符方式

    “%s%d%i”%(a,b,c) 最基础的格式，在定义字符串时，%代表占位符，s为给这个占位符指定数据类型为str，d和i指定为整形。再在字符串后紧挨着书写%()，括号内根据前面字符串的占位符数量和次序以及数据类型依次一一对应填充内容。

    这里的字符串可以用变量代替。

    n = “%s%s%s%s%s”

    print(n%(a,b,c,d,e))

  2. f"{}"方式。此方式最简洁方便，但是3.6版本才开始有的功能，建议先不用，工作中可能遇到3.6以下版本工作？

n = 1

m = 2

num = f"{n}+{m}={m*n}"

print(num)

1+2=2

f作为头标，表示接下来的这个字符串我可以用占位符，然后直接在字符串内容中用{变量或其他}拼接其他字符串。

  1. fomat

五：while循环

  1. while 条件 :

    代码块，成立则执行并持续循环直到不成立往下走

while 条件： 代码块 break，退出并结束break所在的循环。 continue 退出本次循环并继续下一次循环条件判断。 else：当while不是被break结束的时候，即正常条件判断不成立时结束的情况下，执行这里。

六：运算符

  1. 算数运算符

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

  2. 赋值运算符

    • =直接赋值，+=1原值+1赋为新值，-=1，*=，/=，//=，%=，**=

  3. 比较运算符

    • ==等于，>大于，<小于，>=大于等于，<=小于等于，!=不等于

  4. 成员运算符

    • in 在里面，not in 不在里面。

  5. 逻辑运算符

    • not不是，not在这里最高优先级。and并且，和，与的意思，第二优先级。or或者，最低优先级。

七：整型

  1. print(num.bit_length()) 求十进制的数字转换成2进制时的位数。

八：布尔值

  1. boll,布尔值，True 真 False假

  2. print(bool())输出后面括号内容的布尔值。

  3. boll(input())取输入内容的布尔值。

  4. 数字0是False，其他数全都是True。

  5. “”两个引号间没内容的空字符串，布尔值是False，有内容的都是True

  6. print(int(False))输出的是将布尔值整形化，结果是0. print(int(True))的结果是1

  7. print(str(True))把布尔值转换成字符串相当于“True”，同理“False”

九：字符串

  1. 字符串用于存储数据的。用引号引起来的是字符串，‘ ’两组单个单引号，“ ”两组单个双引号，‘’‘ ’‘’两组3个单引号，“”“ ”“”两组3个双引号

  2. 下标（索引）name = “meet” print(name[2]),从左向右开始数，从0开始按01234的顺序数。这个print取的值是meet当中第三个字母，就是右边的e。

    print(name[-3]),这里加了-号，就是从右往左数，同样是012345这样数。

  3. 切片

    name = “abcdefghijklmnopqrstuvwxyz”

    print(name[5:-3])这里取的值是从第5位开始取下一位，取到右数第3位的前一位。

    print(name[0:10:4]) 0是起始位，10是终止位，4是步伐，每4位取一次数。步长位不写默认位1。起始位和终止位。步长位默认1，且是从左往右跳。

    起步位如果在后面，结束位在前面，也是可以的，但一定要注意方向。

  4. 步长7

  5. 字符串常用的方法

    1. 大小写转换

      1. upper 所有字母变为大写

      2. lower 所有字母变为小写

      3. swapcase()大小写互换

      4. casefold 转换小写,覆盖的内容比lower更广泛,比如德语字母

      5. title 把每个单词的首字母变为大写,以非字母隔开视为单词

      6. s.capitalize()首字母大写,整个字符串的第一个字母变成大写.

    2. 切来切去

      1. center(20,*)把字符串拉长并用星号扩充,原字符串填充在中间,单个的星号优先在左边.

      2. strip() 去掉两边的空格,空白,换行符制表符等.括号内也可以输入其他内容

      3. rstrip去掉右边的空格空白

      4. lstrip去掉左边的空格空白

      5. name.replace('n','s',2)#将name里的面n替换成s,默认全部替换，可加，个数，从左往右换n个。

      6. split()#将name以括号内容切割成多个部分。()内的内容会损失掉,返回的结果是一个列表.默认是用空格切.

        1. 如果字符串内没有要切割的内容,切割结果是将这个字符串转换成一个列表

        2. 如果字符串切割部分在开头或结尾,切出来的列表会有一个空字符串做元素

        3. 如果字符串切割部分就是字符串本身,那么切出来的列表是两个空字符串元素.

    3. 格式化输出

      1. s1 = "我叫%s,我今年%s岁了,我喜欢%s"%("名字","年龄","爱好")

      2. s1 ="我叫{},我今年{}岁了,我喜欢{}".format("名字","年龄","爱好")

      3. s1 ="我叫{0},我今年{2}岁了,我喜欢{1}".format("名字","年龄","爱好")#这里可以用索引下标指定位置精准替换

      4. s1 ="我叫{name},我今年{age}岁了,我喜欢{hobby}".format(name="名字",age="年龄",hobby"爱好")用这个更清晰直观,但需要多输入内容.

    4. 查找

      1. print(name.startswith('a'))#name是否是a开头。返回结果是bool值

      2. print(name.endswith('i'))#name是否是i结尾。返回结果是bool值

      3. name.count('z')#name里有几个z,计数

      4. s.find 找位置,如果能找到,是报查找内容的第一个字符的索引下标返回.如果找不到,返回-1.

      5. s.index 找索引,如果能找到,返回查找内容的第一个字符的索引下标,找不到则报错.

    5. 条件判断

      1. is.alnum()是否只由字母,数字,中文组成

      2. isalpha()是否只由字母和中文组成.

      3. isupper()是否有大写字母并且没有小写字母,其他中文和符号无视.

      4. islower()是否有小写字母并且没有大写字母,其他中文和符号无视.

      5. isdigit()是否由纯数字组成.①这种符号也会被认位是数字,但无法int使用.会报错

      6. isdecimal()10进制阿拉伯数字,这个最常用.

      7. isnumeric()阿拉伯数字,中文大写数字,中文小写数字都可以.壹贰叁肆伍陆柒捌玖拾

    6. 长度 len(字符窜或变量名),len()是内置函数,可以直接用.当一个数字用.len的括号内可以是空字符串,但不能没东西.也就是说len最小为0.

    7. 计数 s.count("")

十：for循环

十一：range范围

s = range(1,10) 取头不取尾.从1取到9.取不到10.

print(s) range(1,10) 输出的是range(1,10)本身这个格式.

print(list(s))输出的是[1,2,3...,9]这个列表.

 

十二：列表

  1. 定义:

    1. 能装对象的对象. []中括号,内每个元素以括号隔开,单一元素需要有逗号,没有元素可以为空.

    2. li = list("1234")迭代定义列表.

  2. 索引和切片

    [start:end:step]

  3. 列表操作

    1. 反转 li.reverse(),把列表反过来放.

    2. 升序 li.sort(),

    3. 降序 li.sort(reverse=True)

  4. 增加元素

    1. append()追加末尾

    2. insert(索引值,内容)指定位置添加

    3. extend()扩展添加,可迭代对象,迭代里面每个元素进列表.

    4. 合并[]+[]

  5. 删

    1. pop()默认删除指定位置,可以指定位置,有返回值.

    2. remove()元素名称删除

    3. del索引,切片删除

    4. clear清空

  6. 改

    1. li[索引] = 内容

    2. li[切片] = 步长为1是,切片2个以上元素,添加内容可以任意数量. 步长不为1时,元素数量需要一一对应.

  7. 查:索引,切片,步长,for循环,while循环. li.index('查找内容')

  8. join, "_".join(li),用下划线把后面的可迭代对象链接起来.

十三:元组

  1. tuple, 小括号包起来,元素间逗号隔开.定义

  2. tu = tuple("12345"),迭代字符串定义.

  3. 不能修改.

  4. tu.count('3')元组中3的数量

  5. tu.index('1')元组中第一个1的位置.

十四:字典

  1. 定义

    1. 关键字dict,大括号{}包涵,键值对."键":"值"

    2. dict(k=1,k1=123,k2='aa'),定义字典.

    3. dic = dict.fromkeys(可迭代对象,任何内容),迭代第一项做键,后面内容做所有键的值.

  2. 键:必须可哈希(不可变的数据类型),并且是唯一的. 字符串,数字,元组. 不能是列表. 字典本身是可变的.

  3. 值:任意

  4. 不同的键之间是无序的,相同的键根据时间先后,后面键的内容直接覆盖前面的.

  5. dic = {'a':'b','b','c'}

  6. 增:

    1. dic.setdefault('c','aaa'),添加的键如果不在字典里,新加进去.如果在字典里,不进行任何操作.

    2. dic['s'] = 'ssss',添加新的键值对.

    3. dic.update({1:2,"a":"a1"}) ,有就改,没有就加.

  7. 删:

    1. dic.pop('a') ,pop有返回值,为被删除值.

    2. del dic[键],后面不加是直接删.

    3. dic.clear 清空

  8. 改:

    1. dic['b'] = '值',跟增一样的写法.有就改,没有就增.

    2. dic.update({1:2,"a":"a1"})

  9. 查:字典的查询只能通过键获取值,不能通过值获取键.

    1. print(dic['c'])如果有键就返回键所对应的值,如果没有就报错

    2. print(dic.get('a','如果没有就返回这里的内容,不写默认返回None'))

  10. 其他操作

    1. dic.keys 获取键

    2. dic.values()获取值

    3. dic.items获取键和值,出来的是多个元组,每个元组对应一个键值对.

    4. print(id(a)),输出a的内存地址.

    5. enumerate(dic,1)枚举,第二个参数是起始数,默认0,可以自己写.

  11. 字典的作用

    1. 存储大量数据,相对来说,比列表更适合存大量数据.

    2. 字典的查找比较便捷,因为键值是自己编辑的.

    3. 数据之间可以关联

    4. 字典比较消耗资源

十五:小数据池

  1. 代码块:一个类,一个模块,一个函数,

  2. 在CMD终端中,每一行代码就是一个代码块.

  3. 小数据池int支持范围 -5 -- 256,不同代码块之间用范围内数字时也是同样的地址. 在相同代码块时,所有值相等的内存地址也一样.

    1. is是判断内存地址是否相同,==是判断值是否相同.

  4. 字符串:

    1. 字符串做乘法的时候结果的长度在20以内,地址一样.长度超过20,进行驻留

    2. 自己定义的字符串,如果仅由字母,数字,下划线组成,不限制长度.包含其他内容的,驻留.

    3. 特殊字符(中文除外)定义1个的时候符合小数据池.超过1个驻留.

  5. 布尔值,True和False两个驻留.

十六:集合

  1. 定义

    1. 集合{1,2,3,False,(1,2,3)},无序,可变,元素不会重复,重复时只留一个,元素是不能变的可哈希的.

    2. s = set ('1234')迭代创建集合.

  2. 增

    1. s.update()迭代添加

    2. s.add()添加内容

  3. 删

    1. del s 删除整个集合

    2. s.clear 清空

    3. pop()随机删除1个

    4. remove(指定元素删除)

  4. 改 没有直接改的方法,先删掉一个,再添加一个.就可以达到修改的目的了.

  5. 集合可以用len()计数.

    1. s1 - s2 差集

    2. s1 | s2 并集

    3. s1 & s2交集

    4. s1 ^ s2 差集合并,反交集.

    5. s1 > s2 包含并且至少多一个元素

    6. s1 < s2 被包含并且至少少一个元素.

    7. frozenset({1,2,3,4,5})冻结集合. 冻结后的集合,是不可变得.

  7. 集合主要用于去重复.

  8. list(set(li))从列表转换成集合再转换回列表,就去掉重复项了.但需要注意的是,返回的列表可能顺序跟原来的不同.

十六:深浅拷贝

 

对比赋值,浅拷贝,深拷贝的区别.

赋值:变量名不同,但变量地址一样,指向地址也一样,指向的内容也一样.

十七:类型转换

int整形,str字符串,bool布尔值,list列表,tuple元组,dict字典,set集合.

  1. int str(int)转换成字符串. int不能直接转换成列表,字典,集合,元组.

  2. str

    1. 转换成int,str必须是阿拉伯数字,int(str)

    2. str转list

      1. li = list(str) 把字符串里的每一个字符,按顺序变成列表里的元素.

      2. str.split() 切割转,

        1. 为空时,或括号内内容在字符串中不存在时.把整个字符串作为一个元素组成一个单元素列表.

        2. 括号内内容在字符串中存在时,这个值换成列表中的逗号,其他被这个值(逗号)隔开的内容变成元素.逗号两边或某一边没有内容时,用空字符串''代替元素.(就是说如果这个值在两边,那么就会多一两个空元素)

    3. list转str

      1. str(list),把整个列表两边套上引号,变成整体字符串,包含其中的方括号,元素,逗号等等所有内容.

      2. ('字符串').join(列表),注意这个格式,是用字符串去链接列表的每个字符串元素. 字符串内容可以为空,也可以是任意字符串. 列表内只能由字符串元素组成.由数字或列表嵌套,等等会报错.

    4. str转tuple tuple(str),迭代添加字符串中每一个字符到元组中

    5. tuple转str str(tuple)将整个元组变成要给字符串,同列表. 可以先把元组转成列表,然后用join命令去处理.

    6. str转dict 字典比较特殊,每个元素要两个值,没有直接转换的方式.可以通过批量创建命令,

      dic=dict.fromkeys(str,值) 这里会迭代str把每个字符变成键,他们共享一个值. 注意这个值如果是可变类型,那么一个变其他的也跟着变.

    7. dict转换str str(dict),整体变成字符串. 可以通过dic.keys()把keys拿出来做成高仿列表之后join拼接变成字符串,通过dic.value把值拿出来做成高仿列表之后join拼接变成字符串.

    8. str转set set(str)直接迭代字符串内容添加到集合中.

    9. set转str str(set)整个转. 可以让set变成列表后做join操作.

  3.  

  4.  

十八:编码升级

s = '编码,解码' encode()编码,decode()解码

s1 = s.encode("gbk")

十九:文件操作

  1. f = open("文件路径文件名扩展名",mode="r打开模式",encoding="UTF-8编码集")

  2. content = f.read() 读取内容,默认全部读取,可填写读取字符数,注意换行符也计数.

  3. line1 = f.readline() 读取一行内容,注意换行符,可line1 = f.readline().strip()去掉换行符

  4. line2 = f.readline() 跟上一行代码连在一起就是读取下一行,因为光标移动了.

  5. content = f.readlines() 读出来以行为单位,每行做为一个元素.形成一个列表.

  6. f是一个可迭代对象,因为是大字符串.

for line in f:
    print(line)

  1. 打印出来的是每一行

  2. f.close()关闭,通常操作完文件要关闭.

  3. f.tell返回光标当前位置,按字节算.

  4. with open(文件路径,mode,encoding) as f,open(文件路径,mode,encoding) as f1

  5. import os

    1. os.rename("原名","新名")

    2. os.remove('文件名')删除这个文件.

day10自学,加速.

globals()查看全局作用域中的内容

locals()查看当前作用域中的内容

goobal 在局部引入全局变量

nonlocal在局部,引入离他最近的某一层的局部变量. 引不到全局变量.

 

<function func at 0x000001AE9D4F2EA0>出现类似这样的结果,是指引用的变量是个代码地址,后面加个括号可以直接引用代码地址里的内容.

 

iter(li)把列表li变成要给生成器.

 

内置函数

eval剥去字符串的外衣,返回本质.这个本质必须是数字或变量名等等可以单独存在的.不能用的剥出来会报错.

exce 把字符串里面的内容当代码来运行..这段代码必须符合语法,可以是空,变量名等,但不合语法就会报错.配合使用,可以剥开两层.

闭包

print(ret.__code__.co_freevars)ret是个疑似闭包的函数,后面获取自由变量函数.
下面结果有自由变量,就是闭包.

 

装饰器

def func():
    print('这是原函数主功能')
def warpper(f):
    def inner():
        f()
        print('这是在原函数的基础上,加的新功能')
    return inner
func = warpper(func)# 新的func变成了原func没有改变任何源码的基础上,加了warpper功能.
#如果没有inner新这一层定义函数,那么在定义新func的同时,就执行了旧func,改变了旧func的状态.
func()#此时的新func没有改变代码,没有改变调用方式和调用状态.执行完原功能后还能执行新功能.

day19

日志:

  1. 系统日志:记录服务器的一些重要信息:监控系统,cpu温度,网卡流量,重要的硬件的一些指标,通常是运维人员用的. 记录操作指令

  2. 网站日志:访问异常,网站各板块的访问量,点击率,等等.蜘蛛爬取次数等.

  3. 辅助开发日志:开发人员在开发项目中,利用日志进行排错,排除一些避免不了的错误(记录).辅助开发.try,

  4. 记录用户信息的日志:大数据.消费习惯,新闻偏好,等等(数据库解决)

日志版本

  1. Low版(简易)

  2. 标准()

  3. 旗舰(开发使用)

day20 collections模块

提供特殊的数据类型

面向对象

类

网络协议

 

金融量化

ipython交互器

日常功能

  1. 安装 pip3,

  2. 有行数提示.并且行数可以供后续操作这一行的代码

  3. tab键自动补全 list.ap 此时按tab键会补全list.append, list.此时按tab键,会把所有方法列出来供选

  4. cd,cd..等命令,可以打开文件位置,仿照cmd的命令.

  5. !加cmd命令,可直接执行cmd的命令

  6. # 模糊搜索等功能
    list.*pp*?  #自动补全为list.append  
    a.__*__?  #自动弹出所有双下方法供选择
    a?  #打印a的大小,数据类型,内容
    def func(a):
        print(a)
    #func? 打印类型,
    #func??  把代码打印出来,以及

  7. 常用快捷键

    1. Ctrl-P或 上箭头 后向搜索命令历史中以当前输入的文本开头的命令

    2. Ctrl-N或 下箭头 前向搜索命令历史中以当前输入的文本开头的命令

    3. Ctrl-R 按行读取的反响历史搜索(部分匹配)

    4. Ctrl-Shift-V 从剪贴板粘贴文本

    5. Ctrl-C 终止当前正在执行的代码

    6. Ctrl-A 光标移动到行首

    7. Ctrl-E 光标移动到行尾

    8. Ctrl-K 删除从光标开始至行尾的文本

    9. Ctrl-U 清楚当前行的所有文本

    10. Ctrl-F 或左箭头将光标向前移动一个字符

    11. Ctrl-b 或右箭头 将光标向后移动一个字符

    12. Ctrl-L 清屏

魔术命令

  1. %run test.py 这里可以直接运行py文件

  2. %paste 命令,打印并执行剪贴板里的代码.

  3. li = [random.randint(1,1000000) for i in range(10000)]
%timeit li.sort()
#上两行代码运行结果195 µs ± 61.7 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)  结果为195微秒上下波动61.7微秒之间,  运行了7轮,每轮运行1万次.得出来的结果范围.

a=1
b=2
%timeit a+b
#结果49 ns ± 2.88 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)  49纳秒上下波动2.88纳秒.   运行了7轮,每轮100万次.得出的结果范围.

  4. %pdb on #打开调试模式开关 %pdb off 关闭调试模式开关.

    • 调试模式下, 运行代码会在报错前停住,之后提示哪里即将报错.可查看代码中指向到当前时的各个变量的值,以便排查错误.

  5. a = 1
b = 2
a+b #这里显示3这个结果打印但没保存 如果用c=a+b保存但不打印
a*b #这里显示2
我需要用到上面的3和2的时候,可以用一个_代表上一个结果.__两个下换线代表上两个.___三个下划线代表上三个结果. _69 一个下划线加一个行数,是对应行数的输出结果.如果69没有输出,会报错.

  6. 目录标签系统

    • %bookmark

  7. cmd模式下,打开jupyter-notebook.exe 可以打开一个网页版的ipython,在这里可以编写博客等内容.提供代码执行并输出功能.提供画图等功能.

三个模块之一: NumPy 数组批量计算

常用命令

import numpy as np

  1. a = np.array(b) 将一个列表b变成一个np列表a

  2. 这个np列表叫做数组,数组内的元素类型需要统一,不能有不同类型.数组设定好之后,元素个数就不能变了,可以改变值,但个数不能变.

  3. import numpy as np
import random
a = [random.uniform(100.0,200.0) for i in range(50)]
a = np.array(a)
x = 6
a * x     #这个np列表可以直接用数学运算符求对应的np列表.
b = [random.uniform(10,20) for i in range(50)]
a*b #可以将两个数组对应位置相乘后得到新的数组
(a*b).sum()还能求和

  4. adtype判断a的类型,a.size是元素个数.

  5. a = np.array([[1,2,3],[4,5,6]])
#二维数组
a.shape#返回(2,3) 两行三列.
a = np.array([[[1,2,3],[4,5,6]],[[7,8,9],[10,11,12]]])
#三维数组
a.shape 
#返回(2,2,3)
a.T #转置,横变竖,竖变横.
a.ndim#列数
np.zeros(10)# array([0.,0,....,0.])浮点数数组
a = np.zeros(10,dtye='int') #上一行结果相同,整形
a = np.ones(10)# 十个1.0组成的数组
a = np.ones(10,dtye='int')#十个1组成的数组
a = np.empty(100)#一百个空数组成的数组,但这100个空数,有值.  是上一次这个内存残存的值.


  6. np.arange(2,10)#2到9
np.arange(2,10,2)#步长为2
np.arange(2,10,0.3)#步长0.3,这个列表长度就会很长了.
np.linspace(0,100,100)#分成100个数,从0到100的等差数列.

  7. 快速生成2维或3维数组

    np.arange(15).reshape((3,5))
#结果是3*5的二维数组
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14]])

索引

  1. 索引,对照上面最后的

    array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14]])
a[0][0]  #索引出第一行第一列的0.

  2. 切片

    一:	一维数组,普通列表切法也能切.
	唯一区别,np切片是浅拷贝.  列表第一层切片是深拷贝,二层是浅拷贝.
	深拷贝,用c = a[0:4].copy()
二:  二维数组
	array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14]])
     a[0:2,0:2]切出来的是,逗号左边是行,右边是列.
     0 1
     5 6

  3. 布尔型索引

    a = [3, 3, 6, 2, 3, 2, 2, 1, 6, 2, 7, 6, 10, 5, 10, 4, 2, 8, 1, 1]
list(filter(lambda x:x>5,a))
a = np.array(a)
a[a>5]

     

 

 

 

 

 

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/zhangweishuai/p/10969549.html