总体回顾.
python学习时,看书和做题相结合,做题会上瘾,实际动手编码也更能提升自己的水平.
有时候会犹豫自己选择哪种方向走下去,陷入四处搜集别人的说法的困局当中(比如周六晚上).其实走哪一条路无所谓,对于目前的我来说,没有基础知识,还处于入门阶段,关键的是先沿着一条路先走下去. 等一段时间过去,积累了足够的知识之后,再去考虑岔路口的问题.
和别人的相处上还需要学习,更加自如轻松
时间利用上,杜绝时间的碎片化.留出一段时间只去做一件事,目标要专注,不要看着这个想着那个. 面对网络上丰富的内容时,不要贪多,先找到一个教程看下去.
9/11 周二
上午:英语课,记单词
中午:睡觉,睡得不够长, 犯困
下午:看了两个视频+ 移动通信的课(上课很困)
晚上:看书补充集合的基本概念19---21 + 理顺学习的思路和步骤.
9/12
上午:读对象一节+随机过程
中午:睡觉,吃饭浪费时间
下午:NS3,时间都碎片化了
晚上:随机过程解决 +读书 +看一点英语文献 +解决便签上的问题.(碎片化的时间)
9/13
上午:读python +最优化
9/14 周五
上午: python编码练习
中午:背单词 睡觉
下午:python------- crossin课程编码练,因为嫌notepad++ 和python shell不好用,新下载了pycharm,并且进一步熟悉了它的用法.
晚上:读python核心编程的部分内容,到了晚上看书已经看不进去了,丧失了耐心,走马观花一目十行看不进去了.
9/15 周六
pycharm使用技巧慢慢地学习
上午: 9------11:30 crossin的编程教室 编程题
下午:pycharm技巧看一看,
以后求职的方向?下一步用python 的练手方向? python网络编程方向,web后端
9/16 周日
晚上: 总结一周,处理所有杂事.
笔记回顾:
===========================开始正文===================================================
==============================================================================
快捷键
alt+p 显示上一行代码
alt + F4 终止在运行的程序
--------------------------------------------------------------------------------------------------------
区分概念
序列(sequence) 顾名思义,成员是有序排列的,包括:
字符串str 列表 list1= [ ],列表是有顺序的 元组 tuple1= ( ) 一旦创建不能被修改.
映像:
字典dict { }体现的是数学当中的映射关系
集合set ( ) 无序的,且 不重复的集合 比如 s=set(‘cheeseshop’) s 为 set([‘c’,’e’,’h’,’o’,’p’,’s’])
/剔除列表(list )num1中重复的数字
方法一:
num1= [1,2,3,4,5,4,3,2,1]
temp = []
for each in num1:
if each not in temp:
temp.append(each)
方法二:利用集合的定义去做，集合中的元素不重复，可以自动剔除重复的元素。
num1=list(set(num1))
forzenset 命令作用: 设置一个不允许被更改的集合
num3= forzenset([1,2,3,4,5])
python 的切片(slice)
python的切片字符用于元组tuple 、字符串str或者列表list，采用的是左闭右开，即包含冒号左侧的第N个数，不包含右侧的数，下面以列表示例
2、双切片字符
双切片：（::）一般是用于按一定的顺序呢取其中某几位元素 或 倒置字符串元组列表。
1）[::N]，N可为正数也可为负数，负号代表从右至左，
N的绝对值代表 每隔(N-1) 取一个，下面以字符串为示例：
对字符串进行切片, split()方法:第一个参数标识: 以 什么符号 分割 第二个参数表示分割几次
string.join(seq)命令,以 string为分隔符,将seq中的所有元素合并成一个新的字符串
介绍OS模块
该模块可以使python程序在不同的操作系统中均能运行,作用是对文件系统中的目录进行操作
import os
os.getcwd()获得当前目录 cwd current work directory
os.chdir(‘e:\\’) 改变目录 change directory
os.listdir(e:\\’) 列举当前盘符下的所有文件名
os.mkdir(‘e:\\a’) 创建新的目录 make 写为mk
python之pickle模块
可以将一堆数据封装成一个文件,独立于代码之外,增强代码的简洁性. 类似于FPGA当中的ROM文件
Em：
#0封装一个模块
import pickle #导入pickle模块
#1.准备好具体的数据
my_list = [123,3,5]
#2.新建一个文件,pickle_file叫做文件对象句柄
pickle_file = open(‘my_list.pkl’,’wb’)
#3.把数据装到文件中去
pickle.dump(my_list,pickle_file)
#4.关闭文件
pickle_file.close()
#将模块拆解成原始的模样
#1.以二进制形式读取文件
pickle_file = open(‘my_list.pkl’,’rb’)
#2将文件从二进制形式转换回来
my_list2 = pickle.load(pickle_file)
#3 打印文件
print(my_list2)
--------------------------------------------------------------------------------------------------------
类 用类来描述对象
1. 定义类 ,就是一个模子 : 属性+方法
属性: 静态的特征
方法:动态的函数,动作
2. 将类实例化,建立一个对象 ,称为这个类的一个实例 instance
方法一: 在实例instance中添加属性,不在class中设置.
#1 搭建一个模板 术语叫class 类
class Ball:
def bounce(self):
if self.direction == 'down':
self.direction = 'up'
#self用于在实例化对象时,给函数导入参数. 参数就是实例本身嘛.所以用 self
#2 在搭建的模板上进行个性化定制 术语叫实例化
#定义实例 myBall
myBall = Ball()
#添加属性
myBall.direction = 'down'
myBall.color = ‘red’
myBall.size = ‘small’
方法二: 使用__init__方法直接在类定义中提前设置好属性
区分公有和私有
私有只能在 类 的内部访问，公有是指 类 外部也可以访问
定义了一个类，里面有函数和变量，当它们是私有时，这个类外面的函数不能通过任何方式用它们，只能是 类里面的函数 用它们，而公有的则可被任何函数调用
定义私有变量的方法，在变量前加两个“_”下划线，此时变量就成了私有变量.
下图为调用私有变量的方法.
方法一
方法二
继承. 父类与子类. 子类继承父类的一些属性和特点, 从而子类能够共用父类的代码,使得代码更简洁
定义父类
class Parent():
def hello(self):
print(‘正在调用父类方法’)
class Child(Parent):
#在子类的括号里填写父类的名称
pass
#pass 是空语句 什么都不做
c = Child()
c.hello()
正在调用父类方法
如果子类中与父类中有同名的方法(def)或者属性, 调用子类时,以子类的为准,父类的不起作用.
解决上述情况的方法是,在子类中放入父类的方法,并在父类方法中传入子类的实例对象(self).此处的self代表的是子类的
import random as r
#父类
class Fish():
def __init__ (self):
self.x = r.randint(0,10)
self.y = r.randint(0,10)
def move(self):
self.x -= 1
#子类
class Shark(Fish):
def __init__(self):
Fish.__init__(self) #在子类中放入父类的方法,并在父类方法中传入子类的实例对象(self).此处的self代表的是子类的
self.hungry = True
多重继承
class Base1():
class Base2():
class C(Base1,Base2)# 多重继承
使用super()进行继承
super() 的入门使用
在类的继承中，如果重定义某个方法，该方法会覆盖父类的同名方法，但有时，我们希望能同时实现父类的功能，这时，我们就需要调用父类的方法了，可通过使用 super 来实现，比如：
super().__init__()需要的父类的方法
class Shark(Fish):
def __init__(self):
super(). __init__() ==== super() .需要的父类的方法
self.hungry = True
组合 大类里套小类
先定义出来两个小类
class Turtle()
def __init__(self,x):
self.num = x
class Fish()
def __init__(self,x):
self.num = x
然后在大类里放入小类
class Pool()
def __init__(self,x,y):
self.turtle = Turtle(x)
self.fish = Fish(y)
大类中的属性turtle 用小类Turtle 来实例化
大类中的属性fish 用小类Fish 来实例化
def print_num(self)
print(‘共有乌龟%d只,鱼 %d条’ %(self.turtle,self.fish) #写错了
print(‘共有乌龟%d只,鱼%d条’ %(self.turtle.num,self.fish.num) 这样才能访问到x和y嘛
d.count为什么还是10
obj.attr 对应于 a.count b.count d.count 一般先查找实例属性，实例属性没有，再查找类属性 .d.count这个实例属性是存在的,所以d.count仍然还是10
所以一般如果要操作类属性的话, 最好是通过类方法
class C(obejct):
count = 0
@classmethod
def count_update(cls, int):
cls.count += int
class C(object):
count = 0
a = C()
这时候 a.count 是找不到实例变量的，所以上升到了类变量去找 找到了C.count
然后 a.count += 0 , 会变成定义了一个实例变量，但是因为 a.count 找的时候没找到实例变量，所以 C.count + 10 然后赋值给了a.count 实例变量
所以内存地址会发生改变，a.count 是实例变量了
--------------------------------------------------------------------------------------------------------
定义：BNF范式是一种用递归的思想来表述计算机语言符号集的定义规范，又称巴科斯范式(Backus-Naur form)。
内容：
尖括号“< >” 内包含的为必选项。
方括号“[ ] ”内包含的为可选项。
大括号“{ } ”内包含的为可重复0至无数次的项。
竖线“| ”表示在其左右两边任选一项，相当于"OR"的意思。
“::= ”是“被定义为”的意思。
引号里面的内容代表其本身。
举例:我们知道一个句子一般包含主语，谓语，宾语。
其中，谓语可以是动词或者动词短语，主语就是你我他。那么怎么用BNF范式描述呢？
<句子> ::= <主语> <谓语><宾语>
<谓语> ::= <动词> | <动词短语>
<主语> ::= 你 | 我 | 他
如果我们假设一个段落包含多个句子，那么段落定义就是：
<段落> ::= {句子}
EBNF又称扩展的巴科斯范式。EBNF 排除了 BNF 的一些缺陷:
BNF 为自身使用了符号 (<, >, |, ::=)。当它们出现在要定义的语言中的时候，BNF 不能不加以修改或解释的使用。
BNF 有着可选项和重复不能直接表达的问题。作为替代，它们需要利用中介规则或两选一规则，对于可选项，定义要么是空的要么是可选的产生式的规则，对于重复，递归的定义要么是被重复的产生式要么是自身的规则。
.......
扩展BNF（EBNF）引入了一些新的操作符：
?：意思是操作符左边的符号（或括号中的一组符号）是可选项（可以出现0到多次）。
*：是指可以重复多次。
+：是指可以出现多次。
不管是BNF还是EBNF都可以表达成一科语法树。
---------------------------------------------------------------------------------------------------------------------------------
print("%s's score is %d" %('mike',87) 注意这里用的是双引号,不能用单引号,如果使用单引号则会变成这样
注意关键字 False True 首字母大写
函数的返回值,使用return返回参数
print在python2 和python3
在Python2和Python3中都提供print()方法来打印信息,但两个版本间的print稍微有差异
主要体现在以下几个方面：
1.python3中print是一个内置函数，有多个参数，而python2中print是一个语法结构；
2.Python2打印时可以不加括号：print 'hello world'， Python3则需要加括号 print("hello world")
3.Python2中，input要求输入的字符串必须要加引号，为了避免读取非字符串类型发生的一些行为，不得不使用raw_input()代替input()
--------------------------------------------------------------------------------------------------------
continue 的用法
当continue执行时, 会略过本次循环的余下内容，直接进入下一次循环。
sum+=s; print (s,sum) 均被略过
进入下一次for 循环.
--------------------------------------------------------------------------------------------------------------------
函数默认参数：没有提供参数值时，这个参数就会使用代码中预置的；如果你提供了，就用你给的。
返回:
hello world
hello python
--------------------------------------------------------------------------------------------------------------------
*与**
在形参前面加* ** 称为动态参数
1.加* 函数可以接受 多个参数,全放入一个元组 tuple ( )中
def F(*args):
print(args)
F(123,’456’)
得到一个元组(123,’456’)
2.加**,返回字典 { }
def AA(**kwargs):
print(kwargs)
AA(k1=123,k2="456")
将会得到字典
{'k1': 123, 'k2': '456'}
匿名函数 lambda
add = lambda x,y:x+y
add(1,2)
一个概念:正则表达式
python里的模块-------import re
刷过的题目:
表示 1+2+3+….+100
sum =0
for i in range(1,101):
if i>100:
break
else:
sum =sum +i
打印
print(‘*’,end=’ ’) 则不换行.
--------------------------------------------------------------------------------------------------------------------
是否可哈希:
哈希: Hash（哈希） 它是一种加密过的存储结构。它将任意长度的输入，通过散列算法，转换成固定长度的输出。这个输出就是散列的值。
Python 提供了 hash() 函数可对一些值进行哈希，但并不是所有的类型都能被哈希的。只有不可变类型才能被哈希，可变类型不能被哈希。Python 中不可变类型有：int，float，string，tuple；可变类型有：list(列表)，dict(字典)，set(集合)等
for i in range(9) i的范围是 0 到 8
或者写为 range(1,9)
判断回文数的方法有哪些?
一.转换为字符串
1.类型转换 int ----str 得到str1 2.字符串倒序(字符串倒序的方法??) 得到str2 3.比较str1与str2
字符串倒序: 方法一
str2 = str1[::-1]
方法二:
借助列表list [ ] 翻转
str1=(‘abcdefg’)
str2 = [ ]
for i In str1:
str2.append(i)
str2.reverse()
此时得到
str2
['g', 'f', 'e', 'd', 'c', 'b', 'a']
下一步去掉 , 号
str3= ''.join(str2)
str3是’gfedcba'
正则表达式::
re.match() 从字符串的起始处进行匹配.
re.search() 在字符串中搜索,不严格要求从头开始就一样
group() 方法. 返回正则表达式 匹配到的 所有对象
group（）在正则表达式中用于获取分段截获的字符串，解释如下代码（代码来自网络）：
import re
a = "123abc456"
print re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(0) #123abc456,返回整体
print re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(1) #123
print re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(2) #abc
print re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(3) #456
可以看出，正则表达式按照数字-字母-数字的顺序来获取相应字符串，那么分别就是“数字（group（1））--字母（group（2））--数字（group（3））”的对应关系，
其中，group（0）和group（）效果相同，均为获取取得的字符串整体。