黑马程序员技术交流社区

标题: [技术帖]随堂笔记 [打印本页]
作者: 阳光正好    时间: 2018-8-2 11:34
标题: [技术帖]随堂笔记
认识python
优点：简单，易学，开源，高层语言，可移植性(跨平台性强)，解释性，完全面向对象，可扩展性，丰富的
​            库，代码规范
缺点：1.运行速度慢(现在可以用c++改写关键部分提高速度)
​            2.中文资料匮乏(国内正在火起，各方面资料会渐多起来)
​            3.构建框架选择多(中小型web程序开发天下无敌，python语言的优秀，吸引了很多人才)
注释
使用用自己熟悉的语言，在程序中对某些代码进行标注说明，增强程序的可读性
单行注释(行注释)：以#开头，#(# + 空格)右边的所有东西当做说明，而不是真正要执行的程序，起辅助说明作用
​                                     如果在代码尾端进行单行注释要空两个空白字符，后面格式如上
多行注释(块注释)：多行注释通常使用三对单引号或者双引号，一般注释内容太多或者对函数，类进行解释才会用
​                                    到多行注释
变量
变量的命名
标示符可以由 字母、下划线 和 数字 组成，不能以数字开头，不能与关键字重名(区分大小写)
小驼峰: firstName,  lastName    大驼峰：FirstName, LastName
两种划分方式
1.数字型(整型int，浮点数float,布尔型bool，复数型complex)和非数字型(字符串str，列表list，元组tuple
，字典dict)
2.可变类型(列表，字典)和不可变类型(其它)
变量的格式化输出
%s 字符串  /    %03d  十进制整数(中间数字代表位数)  /   %.2f  浮点数   /    %%  输出百分号
print 输出     input   输入   def  定义函数
if 语句
if  条件一 ：
​        print("条件成立输出")
​        if  条件二 ：
​                print("条件成立输出")
​        elif 条件三：
​                print("条件成立输出")
​        else:
​                print(条件成立输出"")
elif 条件四：
​        print(条件成立输出")
else:
​        print("条件成立输出")
逻辑运算
and(且)  or(或)   not(非)
逻辑运算符
+  加   -  减      *   乘     /  除    //   整除    %  取余    **   幂
== 等于    ！=  不等于   >   大于  <   小于   >=   大等于  <=   小等于
赋值运算
=  简单赋值  +=  加赋  -= 减法  *=  乘等 /=  除等  //=  取整等  %= 取余等   **= 幂赋值
while循环
break打破当前循环    continue  进入下一次循环 ，下面代码不执行(当前循环)
计数器 i += 1  循环前先定义i，值大多从零开始
九九乘法表
row = 1
​
while row <= 5:
​
​
# 假设 python 没有提供字符串 * 操作
# 在循环内部，再增加一个循环，实现每一行的 星星 打印
col = 1
​
while col <= row:
    print("*", end="")
​
    col += 1
​
# 每一行星号输出完成后，再增加一个换行
print("")
​
row += 1
函数
def 函数名(形参):
    函数封装的代码
    ……
函数名，模块名的命名规则与标识符相同，调用  函数名(实参)
返回值return    调用函数一方定义一个变量来接收函数的返回结果，return后面代码都不会被执行
可以返还多个值
def demo():
        *a = 1*            *b = 2*
返回多个结果，是一个元组    *`return a, b`*
局部变量和全部变量
变量的引用：【id()】>查数据的内存位置。hash>字典key的定义>key不能为可变类型
分类：定义在函数内部的变量是局部变量，定义在函数外部的变量是全局变量
global ：关键词后面的是一个全局变量，把局部变量提升为全局变量
如果函数内部定义了一个与全局变量相同name的变量，函数内部只会读取内部变量
shift + F6 修改相同序列下变量的名字，点击名字使用快捷键
变量值互换
a = 100b = 6a, b = b, aprint("a = %d" % a)  # 打印的a是变量a
print("b = %d" % b)  # 打印的b是变量b
在函数内部，针对参数使用赋值语句，无论参数是不是可变类型的数据，都不会修改到外部的实参变量
def demo(num, num_list):
    print("内部")
​
    num = 50
    num_list = [1, 2, 3]
    print(num)
    print(num_list)
    print("over")
​
​
gl_num = 60
gl_num_list = [4, 5, 6]
demo(gl_num, gl_num_list)
print(gl_num)
print(gl_num_list)
如果在函数内部，使用方法来改变了可变类型数据的值，函数外面的值也会改变
def demo(num_list):
    # 如果函数内部对这个参数重新赋值，外面的数值就不会被改变
    # num_list = [7, 8] > 重新赋值对外面没作用
    num_list.append(9) > 外面值会变
    num_list.extend([4, 5, 6]) > 外面值会变
    print(num_list)
​
gl_list = [1, 2, 3]
demo(gl_list)
print(gl_list)
​
加等于操作产生的效果
​
def demo(num, num_list):
​
    print("action!")
    # 1. num = num + num  这个格式就等于给变量重新赋值了，外面变量值也会改变
    num += num  # 加等于是不会改变可变类型外部变量的值
    # num_list = num_list + num_list
    num_list += num_list # 本质上是在调用extend方法
​
    print(num)
    print(num_list)
    print("over!")
​
​
gl_num = 9
gl_list = [4, 5, 6]
demo(gl_num)
print(gl_num)
注意！！！
加等于“不可变变量 += 不可变变量”内部值会改变，但函数外部变量的值不会变
加等于中“可变变量 +=(+) 可变变量”本质上是调用extend/join，所以函数外部的可变变量值也会改变
*args作为一个参数表示能接收一个元组
* 函数名(正常参数， 缺省参数， 多值参数)**
​        正常参数 > nums          缺省参数 > gender= True       多值参数  >  *nums(元组）/**nums（字典）
多值参数求和
1.
def  sum_numbers(*num) >>  sum_numbers(1,2,3,4,5)
2
def  sum_numbers(num) >>  sum_numbers((1,2,3,4,5,6))
两种形式结果相同，但1可以处理多值，2要定义多个变量，不符合实际，太麻烦
递归
函数自己调用自己
必须规定一个出口，即终止条件，否则会出现死循环(最小或者最大）   
递归函数调用时，进去时执行调用函数上面的代码，出来时执行调用函数下面的代码
递归函数不擅长数字和的累和，积。会容易死机
递归的层数一般不会太多，常用于遍历文件目录结构
高级变量类型  
列表   元组   字典   字符串
索引(除了字典，所有索引都是从零开始，最大索引=len()-1, 逆向索引从-1开始)
针对查的操作：[]是知道索引查值， ()是知道值查索引
列表 list
增删改查统计排序
增：append(末尾追加)，insert(根据索引插入指定位置)，extend(继承，把一个列表追加到原列表)
删：remove(指定值删除)，pop()(默认末尾删除，索引指定位置删除),  del(内存中删除), clear(清空列表)
改：list[索引] = 新值
查：list[索引] > 查值            list.index(值) > 查索引
统计： len(list)  > 查列表长度           list.count(值)  >  值出现的次数
排序：list.sort()  从小到大     list.sort(reverse=True)    从大到小         list.reverse()     逆序
for  in   迭次循环    while 循环
name_list = ["小明", "小花", "小芳", "小雨", "小白"]
​
# 使用循环遍历
# 在高级变量类型中，一般使用for + 变量 + in+ 列表，而不用while ,当然while也可以用。
​
for my_name in name_list:
    print("某的名字是 %s " % my_name)
​
# 使用while循环
# 第一步，先查询列表索引列表的位数， 用len查询 n-1 为最后一位元素的位置编号
b = len(name_list)
print(b)
​
# 定义计数器变量i
# 下面循环是反方向的
i = 4
​
while i >= 0:
    # 定义一个变量来接收i对应的值
    # my_name = name_list
​
    print("某的名字是 %s " % name_list)
​
    i -= 1
元组  tuple
元组不能进行增删改操作， 保护数据
循环迭历
info_tuple = ("zhangsan", 18, 1.75)
for my_age in info_tuple:
    print(info_tuple)
# 格式化字符串输出
# 格式化字符串后面的“（）”本质上都是元组
print("%s 的年龄是 %d 身高是 %.2f \n" % info_tuple * 10)
字典  dict
1.字典无序
2.一个key对应一个值value，值唯一
3.只能对key进行操作
4.key不能为可变数据类型(list, dict)
增删改查统计
增: dict.update({键值对})，dict_1.update(dict_2) 字典合并
删：dict.pop("key") ,dict.clear( )
改：dict["key"] = 新值
查：dict["key"]
统计：len(dict )
# 把字典根据值的大小进行排序
b = {"key": 9,
     "key1": 5,
     "key2": -1}
c = list(b.values())
c.sort()
# d = dict(c)
print(c)
e = {}
i = 0
for v in c:
    if i == 0:
        e.update({"key": v})
    elif i == 1:
        e.update({"key1": v})
    else:
        e.update({"key2": v})
    i += 1
print(e)
字符串：
判断
str.isspace  只有空白返回True
str.isalnum 全数字或者字母返回True
str.isalpha   只有字母返回True
str.isdecimal 只有数字返回True
str.islower 只有小写返回True
str.isupper 只有大写返回True
大小写替换：
str.upper() 全转大写
str.lower()  全转小写
str.swapcase()  翻转大小写
str.title()  每个单词首字母大写
去空白字符
str.lstrip() 去左边        str.rstrip()去右边        str.strip()去左右
拆分和拼接
str.split(str="", num)          以str为分隔符拆分，分隔成num个子字符串
str.join()                合并所有子字符串
切片
[起点:终点:步数]   左闭右开   取到终点前一位
步数为负则反着数
函数
max() 取大  min()取小  
面向对象
面向过程
1.面向过程和面向对象都是一种编程方式
2.特点 >>>>注重步骤和过程，需求复杂时代码也会很复杂，开发复杂项目时难度极大
面向对象(简称oop)
1.把不同的职能分给不同的人来处理
2.确定职责>>确定不同对象>>对象有多个方法>>完成最后总结,建立主框架顺序的让
   不同对象 调用 不同方法
3.面向对象是更大的封装，一个对象封装多个方法
4.类与对象
   类>>模板，一个类可以有多个对象，对象属性多样，类中定义的属性(变量)和方法(函数)，
​           对象中不能多也不能少
​           类的命名 >> 满足大驼峰命名法(每个单词的首字母都要大写)
​           类的三要素 >>> 类名(根据项目确定类名)、属性(对象的特征描述)、方法(对象具有的行为>动词)
   对象>>类创建出来的一个具体存在，调用类中的方法和属性
   print输出对象变量，会显示出十六进制的id地址(%x)
   self默认为调用类的对象id地址， 对象调用之后print对象的名字就可以在控制台看到内存地址
   初始化方法__ init__(), 又是内置方法  创建新对象后会自动调用初始化方法 >> 给类添加初始的属性
   把希望设置的属性值，定义成into的参数
   末置方法  ——del——(), del方法触发时机：删除对象时会先自动调用del方法执行最后代码，然后对
   象才被删除
​    ——“ ”——等方法不用指定可以自动调用
   同一个类创建出来的各个对象的属性是互不干扰的
class 派生类名（基类）:
类属性
​    def 方法1(self, 参数列表):
​        pass
​    def 方法2(self, 参数列表):
​        pass
@staticmethod
def 静态方法():
​        pass
@classmethod
def 类方法(cls, 参数列表):
​        pass
对象 = 类名（属性参数）
对象.实例方法
对象.实例属性
(1) 封装
(2) 继承
子类继承父类的所有属性和方法（包括私有属性和私有方法），但是子类无法
(3) 多态
(1) 完整语法格式：
try:
​    # 尝试执行的代码
​    pass
except 错误类型1:
​    # 针对错误类型1，对应的代码处理
​    pass
except 错误类型2:
​    # 针对错误类型2，对应的代码处理
​    pass
except (错误类型3, 错误类型4):
​    # 针对错误类型3 和 4，对应的代码处理
​    pass
except Exception as result:
​    # 打印错误信息
​    print(result)
else:
​    # 没有异常才会执行的代码
​    pass
finally:
​    # 无论是否有异常，都会执行的代码
print("无论是否有异常，都会执行的代码")
（2）异常抛出
重写函数，设置判断条件，通过Exception定义错误类型对象ex，并用raise抛出
(1) import 模块名 as 别名
(2) from模块名import 工具名
(3) from模块名import* （导入模块下所有方法，可以直接引用）
一般代码页格式
# 导入模块
# 定义全局变量
# 定义类
# 定义函数
# 在代码的最下方
def main():
​    # ...
​    pass
# 根据 name 判断是否执行下方代码
if name == "main":
​    main()
访问方式
说明

r以只读方式打开文件。文件的指针将会放在文件的开头，这是默认模式。如果文件不存在，抛出异常
w以只写方式打开文件。如果文件存在会被覆盖。如果文件不存在，创建新文件
a以追加方式打开文件。如果该文件已存在，文件指针将会放在文件的结尾。如果文件不存在，创建新文件进行写入
r+以读写方式打开文件。文件的指针将会放在文件的开头。如果文件不存在，抛出异常
w+以读写方式打开文件。如果文件存在会被覆盖。如果文件不存在，创建新文件
a+以读写方式打开文件。如果该文件已存在，文件指针将会放在文件的结尾。如果文件不存在，创建新文件进行写入
File = open（文件名, 读取方式）
file.write()
Text = file.read()
File. Close()







欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2