传智播客旗下高端IT在线教育平台|咨询热线:010-56288220

返回顶部 返回列表
1598 13

[Python专区] Chenke 的Python体验班学习笔记

[复制链接]

3

主题

15

帖子

69

积分

注册会员

Chenke

Rank: 2

积分
69
159813 Chenke 发表于 2017-7-25 23:28:32

Python基础
14-3 grep:文本搜索命令
grep [-选项] ‘搜索内容串’文件名
-v 显示不包含匹配文本的所有行(相当于求反)
-n 显示匹配行及行号
-i 忽略大小写 grep搜索内容串可以是正则表达式。
时间:2017/7/25   知识点:认识和使用Linux系统

14-1 建立链接文件:
ln 软链接:ln -s 源文件 链接文件
软链接不占用磁盘空间,源文件删除则软链接失效。  
硬链接:ln 源文件 链接文件
硬链接只能链接普通文件,不能链接目录。
14-2 重命令mv 原来的文件名 新的文件名
(mv命令其实是一个移动文件的命令,在此过程中可以重命名)
时间:2017/7/25   知识点:认识和使用Linux系统

13-1 删除目录:rmdir 必须为空目录
13-2 删除文件:rm
-i 以进行交互式方式执行
-f 强制删除,忽略不存在的文件,无需提示
-r 递归地删除目录下的内容,删除文件夹时必须加此参数
时间:2017/7/25   知识点:认识和使用Linux系统

12-1 敲了命令不想执行用Ctrl+C ctrl+c:强制中断程序的执行,终止程序进程
12-2 tree 以目录树的方式显示文件
12-3 mkdir A/B/C/D/E -p 在A里面创建B,在B里面创建C,在C里面创建D ……文件不存在的话,-p会自动创建依赖文件
时间:2017/7/25   知识点:认识和使用Linux系统

10-4 绝对路径和相对路径
从/目录开始描述的路径为绝对路径;
从当前位置开始描述的路径为相对路径;
. 表示当前目录; .. 表示上一级目录,即父目录
时间:2017/7/25   知识点:认识和使用Linux系统

10-2 分屏显示:more
10-3 管道:| 一个命令的输出可以通过管道做为另一个命令的输入。
ls -alh /bin |  more 不是所有命令都能用管道
时间:2017/7/25   知识点:认识和使用Linux系统

10-1 输出重定向命令:> ls > test.txt ( test.txt 如果不存在,则创建,存在则覆盖其内容 )
>:覆盖内容
>>:添加内容,追加
时间:2017/7/25   知识点:认识和使用Linux系统

9-1 帮助文档使用        
命令 --help;        
man 命令;
9-2 自动补全:Tab键
9-3 历史命令:history
时间:2017/7/25   知识点:认识和使用Linux系统

8-1 Linux命令格式:  command  [-options] [parameter1]  …
8-2 ls / (参数):显示根目录下的文件信息
8-3 ls -alh(选项)
-a 显示指定目录下所有子目录与文件,包括隐藏文件
-l 以列表方式显示文件的详细信息
-h 配合 -l 以人性化的方式显示文件大小
时间:2017/7/25   知识点:认识和使用Linux系统

7-11.windows 和 Linux文件系统区别:
<1>.widows系统中每个驱动器都有自己的根目录结构,这样形成了多个树并列。即有CDEF等盘区
<2>.Ubuntu没有分盘,只有一个根目录/
7-2. 家目录:/home
7-3.命令pwd:查看当前目录的完整路径
7-4./斜杠  \反斜杠-横杠 _下划线 |竖杠
7-5.命令ls:查看文件信息
7-6.命令cd:切换目录
7-7.命令touch:创建文件
7-8.命令mkdir:创建一个文件夹
7-9.命令clear:清屏
时间:2017/7/25   知识点:认识和使用Linux系统

1.    常用Linux命令
<1>查看文件信息:ls     -a 显示指定目录下所有子目录与文件,包括隐藏文件     -l 以列表方式显示文件的详细信息     -h 配合 -l 以人性化的方式显示文件大小
时间:2017/7/25   知识点:认识和使用Linux系统

1.操作系统:一种特殊的软件,向下能够直接控制硬件,向上能支持应用程序的运行,简称OS。 2.操作系统可以同时运行多个应用程序
时间:2017/7/25   知识点:认识和使用Linux系统

9-1 命令模式->编辑模式:i 末行模式:先回到命令模式:Esc 再输入”:wq“,就可以保存退出
9-2 进入编辑模式:
小写字母:
i:  插入光标前一个字符   
a: 插入光标后一个字符  
o: 向下新开一行,插入行首
大写字母:
I: 插入行首  
A: 插入行未
O: 向上新开一行,插入行首
9-3 vi 命令:
yy:复制 光标所在的一行
4yy:复制光标所在的位置开始共4行
p:粘贴 dd:删除光标所在的一行
2dd:删除光标所在的行向下2行
dd:实际上就是剪切,不粘贴就是删除
移动:h左  j下  k上  l右 H:当前屏幕的上方 M:当前屏幕的中间 L:当前屏幕的下方
Ctrl-f:下翻1页 Ctrl-b:上翻1页
Ctr-d: 向下翻半屏  Ctr-u: 向上翻半屏
20-G:定位到第20行
G:回到文件末尾
gg:回到代码第一行
w: 以单词为划分,向后一次移动一个单词
b:向前一次移动一个字  
D:从当前光标开始一直剪切到行末
u:撤销刚刚的操作
ctrl-r :反撤销
d0:从当前光标处剪切到行首
dw:删除光标开始位置的字,包含光标所在字符
时间:2017/7/25  知识点:Linux命令

7-1  第一个字母:-:表示文件;d表示文件夹
后9个字母分3组,分别是:  文件拥有者的权限,同组者的权限,其他组的权限
r :可读取
w:可写入
x :可执行   
修改文件权限: chmod u/g/o/a +/-/= rwx 文件名
u:user 表示该文件的所有者
g:group 表示与该文件同组
o:other 表示其他以外的人
a:all 表示这三者皆是
数字法: r 读取权限,数字代号为 "4" w 写入权限,数字代号为 "2" x 执行权限,数字代号为 "1" - 不具任何权限,数字代号为 "0"
chmod u=7,g=5,o=4 filename
或者
chmod 754 filename
时间:2017/7/25   知识点:Linux命令

6-1 userdel -r 用户名 删除用户和相应的家目录
6-2 su - xxxx 切换用户,并切换到相应的家目录
6-3 sudo -s 进入root
6-4 $表示普通账户       #表示root账户
6-5 用户组 新创建的用户,默认不能sudo,需要进行一下操作:
sudo usermod -a -G adm 用户名  
sudo usermod -a -G sudo 用户名
时间:2017/7/25   知识点:Linux命令

5-1 多用户:不用退出当前用户的情况下,可以用另外的用户来进行操作
5-2 添加用户 sudo useradd 用户名 -m cat /etc/passwd:查看系统当前用户名
5-3 切换用户:su su python
5-4 设置用户密码:passwd 用户名
5-5 查看当前用户:whoami
5-6 退出登录账户: exit 5-7 ssh python@ip地址:远程登陆该IP地址的电脑 Windows上面没有ssh命令,可以下载软件putty代替,效果差不多。输入用户名和密码后,可以远程连接Linux。软件Xmanager下的Xshell
时间:2017/7/25   知识点:Linux命令

4-1 shutdown -h now  立刻关机,其中now相当于时间为0的状态 shutdown -h 10 10分钟后关
4-2  reboot  重新启动操作系统
4-3 检测磁盘空间:df
df -h 查看整个电脑存储的情况
-a 显示所有文件系统的磁盘使用情况
-m 以1024字节为单位显示
-t 显示各指定文件系统的磁盘空间使用情况
-T 显示文件系统
4-4 检测目录所占磁盘空间:du
4-5 查看或配置网卡信息:ifconfig lo 本地环回 测试电脑网络 ens 33 网卡 主要功能:
<1>查看IP地址
<2>修改IP地址 ifconfig ens 33 新的IP地址
4-6 ping:测试远程主机连通性ping (IP)
时间:2017/7/25   知识点:Linux命令

3-1 查看当前日历:cal cal -y 2008 查看2008年的所有日历
3-2 查看当前时间:date 显示时间格式 (date"+%y,%m,%d,%H,%M,%S")
3-3 查看进程信息:ps-a 显示终端上的所有进程,包括其他用户的进程 -u 显示进程的详细状态 -x 显示没有控制终端的进程 -w 显示加宽,以便显示更多的信息 -r 只显示正在运行的进程 ps -aux :显示系统中的所有进程
3-4 动态显示进程:top M 根据内存使用量来排序 P 根据CPU占有率来排序 T 根据进程运行时间的长短来排序 U 可以根据后面输入的用户名来筛选进程 K 可以根据后面输入的PID来杀死进程。 q 退出 h 获得帮助
3-5 htop更强大
3-6 终止进程:kill kill [-signal] pid kill 9133 :9133 为应用程序所对应的进程号信号值从0到15,其中9为绝对终止,可以处理一般信号无法终止的进程。
时间:2017/7/25   知识点:Linux命令

2-2-1 归档管理:tar(打包,压缩) -c 生成档案文件,创建打包文件 -v 列出归档解档的详细过程,显示进度 -f 指定档案文件名称,f后面一定是.tar文件,所以必须放选项最后 -t 列出档案中包含的文件 -x 解开档案文件 -cvf:打包 tar -cvf  打包的名称  打包的文件 -xvf:解包
2-2-2 压缩 tar -zcvf  xxx.tar.gz  *py 解压:-zxvf 解压到指定路径: tar -zxvf xxx.tar.gz -C 路径
时间:2017/7/25   知识点:Linux命令

2-1-1 查找文件:find 格式: find ./ -name '*.sh'  查找当前目录下所有后缀为.sh的文件 find /tmp -size +2M  查找在/tmp 目录下大于2M的文件
2-1-1 获取权限:sudo
时间:2017/7/25   知识点:Linux命令



回复

3

主题

15

帖子

69

积分

注册会员

Chenke

Rank: 2

积分
69
 楼主| Chenke 发表于 2017-7-26 21:27:19
本帖最后由 18380582253 于 2017-7-27 08:52 编辑

第二节 python语法基础
1-1Ubuntu软件安装
        配置镜像源:
        vi /etc/apt/sources.list
        配置完后需要更新:
        sudo apt-get update
        软件下载:
        sudo apt-get install sl

2-1 FTP服务器 samba服务器

3-1 将命令放进文件里面去,这个文件还能执行,叫shell脚本 .sh文件

3-2 C语言和python的一些区别:
        C语言:先编辑,再编译,再运行
         python:编辑完直接运行
         
         python xxx.py :
         该命令其实是运行了python的解释器,对程序进行编译,一边运行一遍翻译。
         看上去是直接运行的效果

7-1 运行python程序的方法:
        第一种方法:python XXX.py
        第二种方法:python + 回车  (交互模式)。相应的还有python3,ipython,ipython3
        进入交互模式>>> 可以用来测试一些基本语法
        注意:输入 exit() 退出交互模式

7-2 版本问题
        python 默认是python2
        python3 是 python3版本

7-3 ipython 支持Linux命令,支持自动补全,退出直接用exit
        同理还有ipython3,对应python3

8-1 注释问题
        单行注释:以#开头
        多行注释:三个单引号或者三个双引号,如:
        '''
        akdjflas
        '''
         或者
         """
         asdf
         """
9-1 python2的中文编码问题
        python2代码中有中文的话不能直接执行,需要在开头加上
        #coding=utf-8  
        或者
        #-*- coding:utf-8 -*-

10-1 变量的定义:
        num1 = 100
    num2 = 87  
    等号右边是值,变量就直接等于值
    result = num1 + num2
    等号右边是表达式,先计算表达式的值,再赋值给result
    都是变量的定义方式
    num1和num2都是变量,将变量num1和num2相加,然后放到变量result中

    变量名第一次出现时,才叫定义,第二次出现在等号左边,就是给变量赋值
    num1=num2-10        #给变量num1重新赋值

11-1 输入函数 input()
        high = input("请输入你的身高:")
        程序从键盘中获取输入的值,并赋值给high

11-2 输出函数 print()
        print("hello world")
        print也可以打印变量值

        age = 18
        name ="Chenke"
        print("age变量的值是:%d"%age)                  #打印变量值
        print("姓名:%s, 年龄:%d岁"%(name,age))#打印多个变量值

11-3 打印一个名片信息
        在python3.0以后的版本中,raw_input和input合体
        python3里面input默认接收到的事str类型,可以用
        x = int(input("x: ")) 来接收数字

12-1 python2和python3中的 input()不一样
        python2 raw_input 和 input()
        python3 只有 input() 返回字符串类型


13-1 if 判断语句
        使用格式:

          if 要判断的条件:
                条件成立时,要做的事情

        代码的缩进为一个tab键,或者4个空格

13-2 变量类型
        命令:type(变量名) 查看变量类型

常用变量类型:
        <1>Number
                int
                long
                float
                complex(复数)
        <2>布尔类型:True  False
        <3>String(字符串)
        <4>List(列表)
        <5>Tuple(元组)
        <6>Dictionary(字典)

数据类型转换:
        age = int(intput()) #将输入的数据转换成一个整数
        类似的,还存在其他类型转换:
        long(x [,base ])        将x转换为一个长整数
        float(x )                    将x转换到一个浮点数
        str(x )                       将对象x转换为字符串
回复

3

主题

15

帖子

69

积分

注册会员

Chenke

Rank: 2

积分
69
 楼主| Chenke 发表于 2017-7-27 22:11:32
14-1 if-else语句
使用格式:
        if 条件:
                满足条件执行
        else:
                不满足条件执行

程序在运行过程中选择性执行程序

15-1 if 条件满足或不满足时执行多条语句
        if 条件:
                语句1
                语句2
                语句3
        else
                语句4
                语句5
                语句6
        语句7
if 条件满足时,只会执行有Tab键的语句1、2、3,不会执行未Tab的语句7
else 同理

16-1 标识符和关键字

标识符:
开发人员在程序中自定义的一些符号和名称
标示符是自己定义的,如变量名 、函数名等
标示符的命名规则:
        <1>标示符由字母、下划线和数字组成,且数字不能开头
        <2>起一个有意义的名字:
                驼峰命名法->小驼峰式命名法:myName
                                  ->大驼峰式命名法:FirstName
关键字:
python一些具有特殊功能的标示符
关键字是python已经使用的了,不允许自己定义和关键字相同的名字的标示符
import keyword        #导入keyword工具箱
keyword.kwlist        #查看关键字

17-1 运算符
<1>算术运算符
+        加       
-        减       
*        乘       
/        除       
//        取整除        即商
%        取余       
**        幂        返回x的y次幂 a**b 为10的20次方

注意:*        对字符串使用时:
         “H”*10
结果:“HHHHHHHHHH”

18-1 print 一次输出多个变量
a = 10
b = 20
print("%d %d"%(a,b))

19-1 比较运算符、and 、or
比较运算符:比较两个值的运算符,结果是一个逻辑值,不是 TRUE(成立)就是 FALSE(不成立)
==        相等,相等为真。         
!=        不相等,不相等为真。         
<>        不相等,不相等为真。类似于 != 运算符
>        大于
<        小于
>=        大于或等于
<=        小于或等于

逻辑运算符:
and                x and y        布尔"与" - 如果 x 为 False,x and y 返回 False,否则它返回 y 的计算值。        (a and b) 返回 20。
or                x or y        布尔"或" - 如果 x 是 True,它返回 True,否则它返回 y 的计算值。        (a or b) 返回 10。
not                not x        布尔"非" - 如果 x 为 True,返回 False 。如果 x 为 False,它返回 True。        not(a and b) 返回 False

if not (a>0 and a<=50):
        print("lsdjkfg")


20-1 if 条件判断
<1>        if 条件:
                xxxx
#只判断了一件事,只有在条件满足的情况下,才执行程序

<2>        if 条件:
                xxxxx1
                xxxxx2
        else:
                xxxxx3
#实际上是判断了两件事,分别在满足条件和不满足条件时,执行对应的程序

if 判断多个条件的情况
<3>        if 条件1:
                xxxxx1
        elif 条件2:
                xxxxx2
        elif 条件3:
                xxxxx3
        ……
#只要有前面的一个条件满足,就不会判断后面的条件


21-1 程序的3大执行流程:
        <1>顺序执行
        <2>选择执行 (if - else)
        <3>循环执行
循环:
        while 条件:
                xxxxx1
#条件满足时执行程序
demo:

num = 1                                        num = 1
while num<=10:                        while num<=10:
        print(num)                                num++
        num++                                        print(num)
#循环打印,1-10                   1-11
print(num)   print("%d"%num)
这两个效果一样
python没有(do while) (switch case)

22-1 嵌套
if 嵌套
if xxx1:
        ccccc1
        if xxx2:
                ccccc2
        elif xxx3:
                ccccc3
                if xxx4:
                        ccccc4
        else:
                ccccc5
        ccccc6
else:
        ccccc7

while 嵌套

while xxxxx1:
        ccccc1
        ccccc2
        while xxxxx2:
                ccccc3
                ccccc3
i = 1
while i<=5:
        while j<=i:
                print("*",end="")
                j=j+1
        i=i+1
        print("")

23-1 复合赋值运算符
运算符                描述                                   实例
+=                加法赋值运算符                c += a  --> c = c + a
-=                减法赋值运算符                c -= a  --> c = c - a
*=                乘法赋值运算符                c *= a  --> c = c * a
/=                除法赋值运算符                c /= a  --> c = c / a
%=                取模赋值运算符                c %= a  --> c = c % a
**=                幂赋值运算符                c **= a --> c = c ** a
//=                取整除赋值运算符        c //= a --> c = c // a

a *= 12+23 --> a = a*(12+23)

24-1 乘法表
col = 1
row = 1
while col<=9:
        row = 1
        while row<=col:
                tmp = row*col
                print("%d*%d=%d\t"%(col,row,tmp),end="")
                row+=1
        print("")
        col+=1
\t 加一个Tab键使格式对齐

25-1 游戏-剪刀石头布
#1提示并获取用户的输入
import random

player = int(input("请输入 0剪刀 1石头 2布:"))

#2让电脑出一个,产生一个0-2的随机数
computer = random.randint(0,2)

#判断用户的输入
if ((player == 0 and computer == 2) or (player == 1 and computer == 0) or (player == 2 and computer == 1)):
        print("赢了")
elif player == computer:
        print("平局")
else:
        print("输了")

import random                 #添加一个工具箱
random.randint(0,2)        #产生一个0-2的随机数
回复

3

主题

15

帖子

69

积分

注册会员

Chenke

Rank: 2

积分
69
 楼主| Chenke 发表于 2017-7-28 17:21:08
本帖最后由 18380582253 于 2017-7-28 17:22 编辑

字符串

1-1
        a = 100                         #存储的是数字类型的值
                100占一个字节
        b = "hello world"        #存储的是字符串类型的值
                "100"占3个字节
        双引号或者单引号中的数据,就是字符串
        字符串输出:print('asdf')
        字符串输入:c = input('请输入:')
        可以通过 int(),将字符串转换为数字
1-2 获取字符串长度
        num = "hello"
        len(num)
1-3 字符串输入输出:
        print()
        input()

1-4 组成字符串的2种方式:
        a = 'abc'
        b = 'def'
        <1>进行字符串的加法运算
                c = a+b #'abcdef'
        <2>使用格式化符号 %s,和print类似:
                d = '===%s==='%(a+b)        #'===abcdef==='
1-3 字符串的下标
        c = 'abcdef'
        c[0] --> 'a'
        c[1] --> 'b'
        c[-1]--> 'f'
        c[-2]--> 'e'

1-4 字符串切片
        切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。

切片的语法:[起始:结束:步长]
注意:选取的区间属于左闭右开型,即从"起始"位开始,到"结束"位的前一位结束(不包含结束位本身)。
c[2:-1] -->'cde'  #下标为2开始到最后第二个之间的字符
c[2:]   -->'cdef' #结束不写,默认取到最后一个
c[1:-1:2] --> 'bd'#步长为2,每取一次之后,下标加2

1-5 反转字符串(逆序,倒序)
c = 'abcdefgABCDEFG'
c[-1:0:-1]         -->'GFEDCBAgfedcb'        #不能取到0,即第一个字符'a'
c[-1::-1]          -->'GFEDCBAgfedcba'        #空着,表示取完为止
c[::-1]                -->'GFEDCBAgfedcba'
c[::]                -->'abcdefgABCDEFG'
#最后两种的区别,看步长。步长为-的话,就从最后到最前;步长为+的话,就从最前到最后

2-1 字符串的常见操作
        <1>find :检测 str 是否包含在 mystr中,如果是返回开始的索引值(下标),否则返回-1
        demo:
        >>>myStr = 'hello world itcast and asldjfla'
        >>>myStr.find("world")
        6

        myStr.find("a")  -->15  #find 是从左边开始匹配,返回索引值
        myStr.rfind("a") -->30        #rfind 从右边开始匹配


        <2>index
        myStr.index("hello")
        index 和 find 的区别是:找不到时,find返回-1,index则报一个异常
        同理也存在rindex

        <3>count
        myStr.count(str, start=0, end=len(myStr))
        返回 str在start和end之间 在 myStr里面出现的次数

        <4>replace
        myStr.replace(str1, str2,  myStr.count(str1))
        把 mystr 中的 str1 替换成 str2,如果 count 指定,则替换不超过 count 次。
        >>>myStr.replace("a", "A")        #全部替换
        'hello world itcAst And AsldjflA'
        >>>myStr
        'hello world itcast and asldjfla'
        #replace 能够获得一个修改后的值,但是并不能修改myStr的值
        myStr.replace("a", "A",1)        #第三个参数,替换的次数

        <5>split
        myStr.split(str=" ", 2)
        以 str 为分隔符切片 mystr,如果 maxsplit有指定值,则仅分隔 maxsplit 个子字符串
        >>>myStr.split(" ")
        ['hello', 'world', 'itcast', 'and', 'asldjfla']#分割成了一个列表
        应用:可以统计每个单词里面的个数
        切割完后" "里面的字符就不存在了

        myStr.split() #不加参数,空格 \t 等符号全没了,分割成一个列表
        可以用join再重新组合起来
        "".join(myStr.split())

        <6>capitalize
        myStr.capitalize()
        把字符串的第一个字符大写
        <7>title
        把字符串的每个单词首字母大写
        >>> a = "hello itcast"
        >>> a.title()
        'Hello Itcast'
        只是一种显示风格

        <8>startswith
        myStr.startswith(obj)
        检查字符串是否是以 obj 开头, 是则返回 True,否则返回 False

        <9>endswith
        myStr.endswith(obj)
        检查字符串是否以obj结束,如果是返回True,否则返回 False.
        可以检查文件格式:
        >>>file_name = "xxxx.txt"
        >>>file_name.endswith(".txt")
        True
        #说明文件是以.txt结尾,仅判断后缀,不判断内容
        应用:用户输入的文件的格式限制

        <10>lower
        myStr.lower()
        转换 myStr 中所有大写字符为小写

        <11>upper
        mystr.upper()
        转换 mystr 中的小写字母为大写
        应用:同意大小写,方便判断。如用户输入不管输入大写还是小写,全部转换成大写或小写,再用转换后的值进行判断

        <12>ljust:        左对齐
        mystr.ljust(width)
        返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串
        <13>rjust:        右对齐
        <14>center:居中对齐

        <15>lstrip
        mystr.lstrip()
        删除 mystr 左边的空白字符
        <16>rstrip
        mystr.rstrip()
        删除 mystr 字符串末尾的空白字符
        <17>strip
        >>> a = "\n\t itcast \t\n"
        >>> a.strip()
        'itcast'
    删除mystr字符串两端的空白字符
   
        <18> partition
           mystr.partition(str)
           把mystr以str分割成三部分,str前,str和str后
           <19>rpartition
        mystr.rpartition(str)
        类似于 partition()函数,不过是从右边开始.
        返回一个元组

        <20>splitlines
        mystr.splitlines()  
        按照行分隔,返回一个包含各行作为元素的列表
        >>>myStr = "hello\nworld\n"
        >>>print(myStr)
        hello
        world
        >>>myStr.splitlines()
        ['hello','world']

        <21>isalpha
        mystr.isalpha()  
        如果 mystr 所有字符都是字母 则返回 True,否则返回 False
        <22>isdigit
        mystr.isdigit()
        如果 mystr 只包含数字则返回 True 否则返回 False.
        <23>isalnum
        mystr.isalnum()
        如果 mystr 所有字符都是字母或数字则返回 True,否则返回 False
        <24>isspace
        mystr.isspace()
        如果 mystr 中只包含空格,则返回 True,否则返回 False.

        <25>join
        mystr.join(str)
        mystr 中每个字符后面插入str,构造出一个新的字符串
        >>>a = ["aaa","bbb","ccc"]
        >>>b = " "
        >>>b.join(a)
        'aaa bbb ccc'
回复

3

主题

15

帖子

69

积分

注册会员

Chenke

Rank: 2

积分
69
 楼主| Chenke 发表于 2017-7-29 19:56:33
2017/7/29 学习笔记

1、列表

1-1 列表

        用一个变量保存多个数据,列表是其中的一种方法
        字符串可以存储一串信息,列表可以存储多串信息
        
        列表定义的格式为:
                namesList = ['xiaoWang','xiaoZhang','xiaoHua'] #定义了以一个列表
        类似于C语言中的字符串数组,但与C语言不同的是,列表中的元素可以是不同数据类型的,
        C语言一个数组中的元素必须是同种类型。
                testList = [1, 'a']        #不同数据类型
        列表也是一种数据类型

1-2 打印列表
        >>>namesList = ['xiaoWang','xiaoZhang','xiaoHua']
        >>>print(namesList[0])
        'xiaoWang'
        >>>print(namesList[1])
        'xiaoZhang'
        >>>print(namesList[2])
        'xiaoHua'

        改列表的访问方法与数组类似,通过下标访问,如:
        namesList[0] 表示列表的第一个元素'xiaoWang'
        namesList[0] --> 'xiaoWang'
        与C语言二维数组类似,python中也可以通过下标访问字符串,故:
        namesList[0][0] --> 'x'
        namesList[0][1] --> 'i'

        namesList[0] --> 'xiaoWang'
        namesList[1] --> 'xiaoZhang'
        namesList[2] --> 'xiaoHua'
        字符串存在着下标和切片,类似的,列表也可以通过下标访问,也可以进行切片操作
        namesList[1:2] --> ['xiaoZhang','xiaoHua']

1-3 列表的循环遍历
        为了更有效率地访问列表的每个数据,可以使用循环来完成列表遍历
        <1> for 循环遍历
        demo:
                namesList = ['xiaoWang','xiaoZhang','xiaoHua']
            for name in namesList:
                print(name)
    结果:
    xiaoWang
    xiaoZhang
    xiaoHua

    <2> while 循环遍历
    demo:
        namesList = ['xiaoWang','xiaoZhang','xiaoHua']
        length = len(namesList)
        i = 0
    while i<length:
                print(namesList)
                i+=1
        结果:
        xiaoWang
    xiaoZhang
    xiaoHua

1-4 列表的增删改查

增加元素
        <1>添加列表元素append
        已经定义了一个列表后,需要对已有的列表添加一个元素,使用 names.append
        namesList = ['xiaoWang','xiaoZhang','xiaoHua']
        namesList.append('xiaoLi')

        append 只能将字符添加到列表最后
        append 注意:
                >>>a = [1,2,3]
                >>>b = [3,4,5]
                >>>a.append(b)        #将列表b当作一个整体添加到列表a中,
                >>>a
                [1, 2, 3, [4, 5, 6]]
                >>>a = a.append(b)
                >>>a
                >>>type(a)
                NoneType
                说明a.append(b)操作是没有返回值的None,只是对a的值进行了改变
        <2>添加列表元素insert
                insert(index, object) :在指定的位置index前插入元素object
        demo:
                >>> a = [0, 1, 2]
                >>> a.insert(1, 3)
                >>> a
                [0, 3, 1, 2]
                insert起到了一个插队的作用

        <3>合并两个列表
                a = [1,2,3]
                b = [4,5,6]
                c = a+b                #c=[1,2,3,4,5,6]
                还可以采用extend,将一个集合中的元素逐一添加到列表中:
                >>>a.extend(b)         #参数只能是一个列表,不能是单个字符
                >>>a                         #extend是合并
                [1,2,3,4,5,6]

                >>>a.append(b)        #append是将b当做一个整体,添加到列表a中,只添加了一个元素,可以添加单个字符
                >>>a
                [1,2,3,4,5,6,[4,5,6]]
        


删除元素(del,pop,remove)

        <4>根据下标删除元素:del
                del a[1]  删除元素a[0],即2

        <5>删除最后一个元素:pop
                >>>a.pop()
                [4,5,6]
                >>>a
                [1,2,3,4,5,6]
        和 append()是对应的,先进先出,对应的数据结构就是“栈”。
        
        <6>根据元素的值进行删除:remove
                >>>a.remove(1)
                >>>a
                [2,3,4,5,6]
        remove 查找内容进行删除,从前往后进行查找,只删除一次

        <7> 修改元素
        修改元素的时候,要通过下标来确定要修改的是哪个元素,然后才能进行修改
                xxxx[下标] = 新的值                通过下标直接赋值

查找元素(in, not in, index, count)
        <8>in, not in
        查找指定元素是否存在
        in (存在),如果存在返回 True,否则 False
        not in(不存在), 不存在 True,否则 False
        
        demo:
                namesList = ['xiaoWang','xiaoZhang','xiaoHua']
                findName = input()
                #查找是否存在
                if findName in namesList:
                        print('找到了')
                else:
                        print('没找到')
        not in 使用方法类似
        <9>index, count
        index和count与字符串中的用法相同

        demo:
                >>> a = ['a', 'b', 'c', 'a', 'b']
                >>> a.index('a', 1, 3) # 注意是左闭右开区间
                Traceback (most recent call last):
                  File "<stdin>", line 1, in <module>
                ValueError: 'a' is not in list
                >>> a.index('a', 1, 4)
                3
                >>> a.count('b')
                2
                >>> a.count('d')
                0

1-5 名字管理系统

#1.打印功能提示
print("="*50)
print("    名字管理系统V1.1")
print("1:添加一个新的名字")
print("2:删除一个名字")
print("3:修改一个名字")
print("4:查询一个名字")
print("5:退出系统")
print("="*50)

names = []        #定义一个空的列表,用来存储添加的名字

while True:
        #2.获取用户的选择
        num = int(input("请输入功能序号:"))
        #3.根据用户的选择,执行相应的功能
        if num == 1:
                #pass                #占坑,写程序的时候就可以铲除了
                new_name = input("请输入姓名:")
                names.append(new_name)
                print(names)
        elif num == 2:
                del_name = input("请输入要删除的名字:")
                names.remove(del_name)
        elif num == 3:
                #pass
                change_name = input("请输入要修改的名字:")
                after_change_name = input("请输入修改之后的名字:")
                names[names.index(change_name,0,len(names))] = after_change_name
        elif num == 4:
                #pass
                find_name = input("请输入要查询的名字:")
                if find_name in names:
                        print("找到了")
                else:
                        print("查无此人")
        elif num == 5:
                break
        else:
                print("您的输入有误,请重新输入")


2、字典

变量info为字典类型:
         info = {'name':'班长', 'id':100, 'sex':'f', 'address':'中国'}
说明:
        字典和列表一样,也能够存储多个数据
        列表中找某个元素时,是根据下标进行的
        字典中找某个元素时,是根据'名字'(就是冒号:前面的那个值,例如上面代码中的'name'、'id'、'sex')
        字典的每个元素由2部分组成,键:值。例如 'name':'班长' ,'name'为键,'班长'为值
        <1>根据键访问值
         info = {'name':'班长', 'id':100, 'sex':'f', 'address':'中国'}
    print(info['name'])
    print(info['address'])

    <2>列表里面嵌套字典:
    demo:名片管理系统

    <3>查询,根据键访问值
    访问不存在的键,则会报错:
                >>> info['age']
                Traceback (most recent call last):
                  File "<stdin>", line 1, in <module>
                KeyError: 'age'
        
        在我们不确定字典中是否存在某个键而又想获取其值时,可以使用get方法,还可以设置默认值:
                >>> age = info.get('age')
                >>> age #'age'键不存在,所以age为None
                >>> type(age)
                <type 'NoneType'>
                >>> age = info.get('age', 18) # 若info中不存在'age'这个键,就返回默认值18
                >>> age
                18

        <4> info = {键:值,键:值,键:值}
                key:value  称为键值对
                字典中键值对的添加:
                info = {"name":"xiaochen"}
                #添加键值对
                info["age"] = 18
                info["addr"] = "asdf"
                info["asdf"] = "2134"
                >>>info
                {"name":"xiaochen","age":18,"addr":"asdf","asdf":"2134"}
                #添加的时候,键存在的话就是修改,键不存在的话就是增加
                info["age"] = 10 #修改了info["age"]的值

        <5>删除 del
                del info[key]
                eg: del info["age"]
                如果key不存在,则会报异常

                clear :清空整个字典
                >>>info.clear()

        <7>for 循环中的else:
                >>> nums = [1,2,3,4,5]
                >>> for tmp in nums:
                ...     print(tmp)
                ... else:
                ...     print("========")
                ...
                1
                2
                3
                4
                5
                ========
                在遍历过程中如果未遍历完,就一直执行循环内的打印,如果遍历完成,就执行else里面的程序

                在名片管理系统中(使用for-else的方法):
                card_infors =[{'name':'班长', 'id':100},{'name':'sdfg', 'id':100}]
                find_name = input("请输入要查询的名字:")
                for tmp in card_infors:
                        if tmp["name"] == find_name:
                                print("找到了")
                                break
                else:
                        print("没找到")
                注意:其他语言中没有的语法

                在名片管理系统中(使用flag的方法):
                card_infors =[{'name':'班长', 'id':100},{'name':'sdfg', 'id':100}]
                find_name = input("请输入要查询的名字:")
                find_flag = 0
                for tmp in card_infors:
                        if tmp["name"] == find_name:
                                print("找到了")
                                find_flag = 1
                                break
                if find_flag == 0:
                        print("没找到")


        <6> 遍历字典
        字符串遍历
                >>> a_str = "hello itcast"
                >>> for char in a_str:
                ...     print(char,end=' ')
                ...
                h e l l o   i t c a s t

        列表遍历
                >>> a_list = [1, 2, 3, 4, 5]
                >>> for num in a_list:
                ...     print(num,end=' ')
                ...
                1 2 3 4 5

        元组遍历
                >>> a_turple = (1, 2, 3, 4, 5)
                >>> for num in a_turple:
                ...     print(num,end=" ")
                1 2 3 4 5

        字典遍历
                ①遍历字典的key(键)
                >>> dict ={"name":"xiaozhang","sex":"m"}
                >>> for key in dict.keys():
                ...     print(key)
                ...
                sex
                name
        <7>len()
                测量字典中,键值对的个数

        <8>keys()
                返回一个包含字典所有KEY的列表(pyhton2中)
                >>> dict = {"name":"xiaozhang","sex":"m"}
                >>> dict.keys()
                ['name', 'sex']
                >>>
                这个时候我们可以直接对键值进行判断:
                if "name" in dict.keys():
                        print('有这个键')
                以前是使用dict.get("name"),判断一个值存不存在
        
        <9>value()
                返回一个包含字典所有value的列表(python2中)
                >>> dict = {"name":"xiaozhang","sex":"m"}
                >>> dict.values()
                ['xiaozhang', 'm']
               
        <10>items()
                返回一个包含所有(键,值)元祖的列表(python2中)
                >>> dict = {"name":"xiaozhang","sex":"m"}
                >>> dict.items()
                [('name', 'xiaozhang'), ('sex', 'm')]

                for tmp in dict.items():
                        print(tmp)        #tmp是一个元组
                        print("key=%s,value=%s"%(tmp[0],tmp[1]))#通过下标取
                        for A,B in dict.items():
                                print("key=%s,value=%s"%(A,B))                #直接定义两个变量来取


                #得到值后就可以进行遍历
                for tmp in dict.keys():
                        print(tmp)
               
                for tmp in dict.values():
                        print(tmp)

                for tmp in dict.items():
                        print(tmp)

        python3中变成了对象,有些不一样


3、元组

        >>> a = (11,22)
        >>> b = a
        >>> b
        (11, 22)
        >>> c,d = a         #相当于拆包
        >>> c
        11
        >>> d
        22
        >>>
Python的元组与列表类似,不同之处在于元组的元素不能修改。
元组使用小括号,列表使用方括号。

数据类型单一时,用列表
描述一个元素需要多个信息时,用字典,相当于C语言结构体
        >>> aTuple = ('et',77,99.9)
        >>> aTuple
        ('et',77,99.9)
1-1 访问元组
        >>> tuple =("hello",100,1234)
        >>> tuple[0]
        'hello'
        >>> tuple[1]
        100
        >>> tuple[2]=100
        Traceback (most recent call last):
          File "<stdin>", line 1, in <module>
        TypeError: 'tuple' object does not support item assignment
        >>>
        #相当于只读文件,给元组赋值时,会报错

回复

3

主题

15

帖子

69

积分

注册会员

Chenke

Rank: 2

积分
69
 楼主| Chenke 发表于 2017-7-30 22:49:12
2017/7/30 学习笔记


函数

1-1 什么是函数
如果在开发程序时,需要某块代码多次,但是为了提高编写的效率以及代码的重用,所以把具有独立功能的代码块组织为一个小模块,这就是函数
1-2 函数的定义
定义函数的格式:
           def 函数名():
        代码
    这个操作叫做 “封装”
1-3 函数的调用
        通过 函数名() 即可完成调用
1-4 函数参数
定义带有参数的函数:
        def add2num(a, b):
                c = a+b
                print c
调用带有参数的函数:
        >>>add2num(11, 22)
        33
1-5 调用函数时参数的顺序
        def print_num(a,b):
                print(a,b)

        调用改函数:
        >>>print_num(1,2)
        1,2
        >>>print_num(b=1,a=4)
        4,1
注意:
print_num(a,b) 里面的a,b称为形参,也是一个keyword,调用的时候,传递参数,卡伊按顺序写入实参,也可以给keyword赋值的方式传递参数,此时可以调换参数的顺序。
1-6 函数的返回值
在函数调用时,使用return把结果返回给调用者。
        def add2num(a, b):
                c = a+b
                return c
        调用时:
        >>>add2num(1,2)
        3
#调用函数时,保存函数的返回值
        >>>result = add2num(1,2)
        >>>result
        3
1-7 四种函数类型
无参数,无返回值
无参数,有返回值
有参数,无返回值
有参数,有返回值

1-8 函数可以嵌套调用

2-1局部变量
局部变量,就是在函数内部定义的变量
不同的函数,可以定义相同的名字的局部变量,但是各用个的不会产生影响
局部变量的作用,为了临时保存数据需要在函数中定义变量来进行存储,这就是它的作用

2-2全局变量
全局变量:既能在一个函数中使用,也能在其他的函数中使用。
在函数外边定义的变量叫做全局变量
全局变量能够在所有的函数中进行访问
如果在函数中修改全局变量,那么就需要使用global进行声明,否则出错
如果全局变量的名字和局部变量的名字相同,那么使用的是局部变量的。
        a = 100
        def test1():
                global a #用了global,表示在函数中可以对全局变量a进行修改
                print(a)
                a = 200
                print(a)
结果:100
          200
2-3 可变类型的全局变量
在函数中不使用global声明全局变量时不能修改全局变量的本质是不能修改全局变量的指向,即不能将全局变量指向新的数据。
对于不可变类型的全局变量来说,因其指向的数据不能修改,所以不使用global时无法修改全局变量。
对于可变类型的全局变量来说,因其指向的数据可以修改,所以不使用global时也可修改全局变量。

回复

3

主题

15

帖子

69

积分

注册会员

Chenke

Rank: 2

积分
69
 楼主| Chenke 发表于 2017-7-31 18:21:22
2-4 函数中的多个return
函数只要运行到return就会直接结束
第一种方式:
        def test():
                a = 1
                b = 2
                c = [a,b]
                return c
        test()
        [1,2]

在函数中可以利用列表或者元组来返回数据
第二种方式:
        def test():
                a = 1
                b = 2
                return [a,b]
        test()
        [1,2]
第三种方式:
        def test():
                a = 1
                b = 2
                return (a,b)
        test()
        (1,2)
第四种方式:
        def test():
                a = 1
                b = 2
                return a,b        #默认封装元组
        print(test())
        (1,2)
即默认是以元组的形式进行封装
一个函数是可以返回多个值的,但是要将他们进行封装


回复

3

主题

15

帖子

69

积分

注册会员

Chenke

Rank: 2

积分
69
 楼主| Chenke 发表于 2017-8-1 12:13:02

2-1局部变量
局部变量,就是在函数内部定义的变量
不同的函数,可以定义相同的名字的局部变量,但是各用个的不会产生影响
局部变量的作用,为了临时保存数据需要在函数中定义变量来进行存储,这就是它的作用

2-2全局变量
全局变量:既能在一个函数中使用,也能在其他的函数中使用。
在函数外边定义的变量叫做全局变量
全局变量能够在所有的函数中进行访问
如果在函数中修改全局变量,那么就需要使用global进行声明,否则出错
如果全局变量的名字和局部变量的名字相同,那么使用的是局部变量的。
        a = 100
        def test1():
                global a #用了global,表示在函数中可以对全局变量a进行修改
                print(a)
                a = 200
                print(a)
结果:100
          200
2-3 可变类型的全局变量
在函数中不使用global声明全局变量时不能修改全局变量的本质是不能修改全局变量的指向,即不能将全局变量指向新的数据。
对于不可变类型的全局变量来说,因其指向的数据不能修改,所以不使用global时无法修改全局变量。
对于可变类型的全局变量来说,因其指向的数据可以修改,所以不使用global时也可修改全局变量。

3-1 函数可以嵌套调用
多个函数的函数名不能相同
函数的嵌套调用:
        在一个函数内部调用另一个函数
3-2 函数嵌套调用的应用
3-3 函数的缺省参数
        在定义函数时,可以为形参设置缺省参数
        def printinfo( name, age = 35 ):
        # 打印任何传入的字符串
                print "Name: ", name
                print "Age ", age

        # 调用printinfo函数
        printinfo(name="miki" )
        printinfo( age=9,name="miki" )
        以上实例输出结果:
                Name:  miki
                Age  35
                Name:  miki
                Age  9
注意:带有默认值的参数一定要位于参数列表的最后面。
缺省参数可以有多个,但是必须放后面,不能前有参数,后面没有
        def test(a,b = 1, c = 2):
                print(a)
                print(b)
                print(c)
        test(2)
        输出:
                2
                1
                1
        def test(a = 1,b,v):
                print(a)
                print(b)
                print(c)
SyntaxError: non-default argument follows default argument
会报错
函数定义后,实参可以指定传入:
        def test(a, b = 1, c = 2): #这里面的参数b=1,c=2叫缺省参数
                print(a)
                print(b)
                print(c)
函数调用时:(只想给a和c赋值,b用默认值)
        test(1,c = 5)        # c=5 这种参数叫做命名参数
        结果为:
        1
        1
        5
上述程序表明:在进行实参传递时,可以选择给指定的参数传值
当然可以全部用命名参数的方式进行参数传递:
        test(a=1,c=5)

3-4 不定长参数
<1>有时可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数,声明时不会命名。
基本语法:
        在形参前面加上*号
        def sum_nums(a,b,*args): #args可随便命名
                print(a)
                print(b)
                print(args)
执行:
        sum_nums(1,2,3,4,5,6,7)
        1
        2
        (3,4,5,6,7)
        #args 变成了一个元组
加了星号(*)的变量args会存放所有未命名的变量参数,args为元组;
        sum_nums(1,2,3)
        1
        2
        (3,)          #只有一个元素的元组,后面要多加一个“,”号
        sum_nums(1,2)
        1
        2
        ()                #这个时候是一个空元组
意义:当调用一个函数,但是不确定接下来到底要传递多少个值的时候,就用这种方式
<2>将传递进去的任何的值都加起来:
         def sum_nums(a,b,*args):
     ...:     print(a)
     ...:     print(b)
     ...:     print(args)
     ...:          sums = a +b
     ...:     for tmp in args:
     ...:         sums += tmp
     ...:     return sums
     sum_nums(1,2,3,4)
     1
     2
     (3,4)
     10

<3>        不定长参数2:
        def test(a,b,c=33,*args):        #函数定义里面有缺省参数,有不定长参数
                print(a)
                print(b)
                print(c)
                print(args)

        test(1,2,3,4,5)
        1
        2
        3
        (4, 5)
        #这个时候就不使用c=33这个默认参数

加**的变量kwargs会存放命名参数,即形如key=value的参数, kwargs为字典。
        def test(a,b,c=33,*args,**kwargs):
                print(a)
                print(b)
                print(c)
                print(args)

        test(1,2,3,4,5)
        1
        2
        3
        (4, 5)
        #普通方式,并不会存在kwargs中,只会全部在args中
        test(1,2,3,task=99,done=89)
        1
        2
        3
        ()        #args
        {'done': 89, 'task': 99}        #kwargs
函数调用时,输入的多余的参数,不带变量名的放入args里面,以元组方式保存;带了变量名的全部放入kwargs里面,以字典方式保存



4-1 拆包,元组、字典

注意:元组与字典的传参方式
        d = (3, 4, 5)
        e = {"m":6, "n":7, "p":8}
       
        #函数调用时,不带*号和**号
        fun(1, 2, 3, d, e)        #没有变量名,统统给args于是就将d和e都放进了元组中
        1
        2
        3
        (3,4,5,{"m":6, "n":7, "p":8})
        {}
       
        #函数调用时,带*号和**号
        fun(1, 2, 3, *d, **e)        # *和** 表示拆包,将元组拆成一个一个的值,将字典拆成一对一对的 key=value
        1
        2
        3
        (3,4,5)
        {"m":6, "n":7, "p":8}

          * :拆元组
         ** :拆字典

回复

3

主题

15

帖子

69

积分

注册会员

Chenke

Rank: 2

积分
69
 楼主| Chenke 发表于 2017-8-3 00:13:35
2017/8/2 学习笔记

5-1 引用
       
        a = 100
        b = a
在C/C++中,定义了一个变量名为a的变量空间,里面存的值为100
定义了一个变量名为b的变量空间,将100复制了一份给存储在b里面
在C/C++中,有两个变量空间存储着100这个值

在python中,不是这样
        a = 100
在python中,开辟了一个空间,存储了一个值100,然后定义了一个变量名a,a保存的是存储100这个值的存储空间的地址。
        b = a
        将a赋值给b,其实就是将100的地址值赋值给了b,所以b直接指向100
        在内存空间中,就只有一个空间存储着100这个值
相当于C语言中的指针变量:
        int num = 100;
        int *a = &num;
        int *b = a;
python 里面的a和b就相当于上面的*a和*b,直接指向存储100的地址。

id() :得到变量指向的那个值所在的内存空间的地址

引用:用a指向了一个变量空间

5-2 注意点
        a = 100
        a = 200
此时,改变了a的指向,从指向100的内存空间,变成了指向200的内存空间。
那么现在就没有变量指向存储100的内存空间了,这片空间就成了垃圾,在python中有自动回收垃圾的机制

6-1 可变类型和不可变类型
数字         --> 不可变类型
        a = 100
        a = "hello" #不能通过a去改变内容,重新赋值只是改变了指向的地址
        a[0]="Q"    #TypeError:'str' object does not support item assignment
字符串        --> 不可变类型
        a(1,2,3,4)
        a[0] = 5        #TypeError:'tuple' object does not support item assignment
元组        --> 不可变类型       

列表        --> 可变类型
        a = [1,2,3,4,5]
        a[0] = 6
        a
        [6,2,3,4,5]
字典        --> 可变类型

不可变类型:只读
可变类型:可读,可改,可删

infor = {"name":"xiaowang",100:"xiaoli",2.3:"xiaozhang",(1,2):"xiaoxiao"}
infor = {[1,2]:"heihei"} #unhashable type:'list'

字典的存储:将key值拿出来进行哈希算法,得到一个唯一的值,把value存到这个值里面去。key值是混乱的,不是连续的值
取字典的时候,将需要取的key值也进行哈希算法(哈希有一个特点:同一个值进行哈希算法,得到的值是一样的)就可以找到存储的地址,从而找到对应的value值

哈希算法:一种简单的加密算法

列表和字典不能作为key值的原因是:列表和字典军事可变类型,要是其值发生改变,对应的哈希值也会发生改变,那么就不能通过哈希值找到原来key值所对应的value值了。故只有不可变类型的数据类型才能作为key值,如数字,字符串,元组均可作为key值。

7-1 递归
计算一个值的阶乘
<1>
        i = 1
        result = 1
        while i<=5:
                result *=  i
                i+=1
        print(result)

<2>递归
5!=5*4!
4!=4*3!
3!=3*2!
2!=2*1

def get_num(num):
        if num>1:
                return num * get_num(num-1)        #函数里面调用函数本身,这样的函数叫做递归
        else:
                return num

get_num(4)
注意:递归一定要有结束的条件,不能造成死循环。

8-1 匿名函数
用lambda关键词能创建小型匿名函数。这种函数得名于省略了用def声明函数的标准步骤。

lambda函数的语法只包含一个语句,如下:

    lambda [arg1 [,arg2,.....argn]]:expression

    def test1(a,b):
            a+b
    test(1,2)

    test2 = lambda a,b:a+b
调用的时候:
        test2(1,2)
        result = test2(1,2)
lambda函数能接收任何数量的参数但只能返回一个表达式的值
匿名函数不能直接调用print,因为lambda需要一个表达式

应用场合:
<1>自己定义函数的功能(比如自定义加减乘除,功能是作为参数传递的,并没有在函数内部):
    def fun(a, b, opt):
...     print "a =", a
...     print "b =", b
...     print "result =", opt(a, b)
...
>>> fun(1, 2, lambda x,y:x+y)
a = 1
b = 2
result = 3

<2>作为内置函数的参数:
对字典进行排序
列表的排序:
nums = [12,245,3.456,2345,12.3,346,76,7,34,5,765,7]
nums.sort()  #默认下,从小到大排序
nums.sort(reverse = True)
nums.reverse() #倒序,逆序

对列表里面是字典的排序:
        不能直接对字典进行比较
        stus = [
    {"name":"zhangsan", "age":18},
    {"name":"lisi", "age":19},
    {"name":"wangwu", "age":17}]

    stus.sort(key= lambda x:x["name"])

    每次排序比较的时候,是将一个一个字典取出来,即将{"name":"zhangsan", "age":18}赋给了x,x再执行了一个x["name"]的命令,就取出了"name"里面的value。于是比较就变成了"name"的value值的比较

<3>python 是动态特性的
    def fun(a, b, opt):
...     print "a =", a
...     print "b =", b
...     print "result =", opt(a, b)
...

        func_new = input("请输入一个匿名函数:")#在python2中用input输入了一个函数,就相当于定义了一个函数
        #在python3中input都是当作字符串的
        #在python3中需要转换成一个表达式,要加上eval
        # lambada x,y:x+y
        #func_new = lambada x,y:x+y
        fun(1, 2, func_new)
a = 1
b = 2
result = 3

c/C++语言就是静态语言.
8-2  完成两个值的交换
<1>        a = 1
        b = 2
        c = 0

        #交换
        c = a
        a = b
        b = c
#需要第三个中间变量
#不需要第三个中间变量的方法
<2> a = 1
        b = 2

        a = a+b
        b = a-b
        a = a-b
<3>a,b = b,a

8-3 全局变量作为参数传递

a+=a 和 a=a+a 的区别:
<1>
a=100
def  test(num):
        num += num
        print(num)
test(a)
print(a)
结果:
100
200
<2>
a=[100]
def  test(num):
        num += nums
        #如果num指向的是一个可变类型的数据,就可以直接修改num指向的值,如果是一个不可变类型的数据,就会定义一个新的变量,num再指向了这个值。

        print(num)

test(a)
print(a)
结果:
[100,100]
[100,100]

<3>
a=[100]
def  test(num):
        #num += nums        #如果是可变类型,将直接修改num指向的值
        num = num +num
        #先算右边,即 [100] + [100] ---> [100,100],相当于等号右边是一个新的列表,现在将num = [100,100],这意味着将num指向了一个新的列表,与实参a指向的值之间的指向关系断裂
        print(num)

test(a)
print(a)
[100,100]
[100]


回复

3

主题

15

帖子

69

积分

注册会员

Chenke

Rank: 2

积分
69
 楼主| Chenke 发表于 2017-8-3 16:49:20
2017/8/3 笔记


面向对象

1-1 面向过程,所有过程都要考虑到
        面向对象,只要找到能干这事的人,就可以

1-2 类和对象
类就相当于制造飞机时的图纸,用它来进行创建的飞机就相当于对象。
类是抽象的,在使用的时候通常会找到这个类的一个具体的存在,使用这个具体的存在。一个类可以找到多个对象

某一个具体事物的存在 ,在现实世界中可以是看得见摸得着的。可以是直接使用的
类         -->模板
对象     -->实体
对象需要类来创建

1-3 类(Class)由3个部分构成
        类的名称:类名
        类的属性:一组数据
        类的方法:允许对进行操作的方法(行为)

1-4 定义类
class 类名:
        #属性

        #方法
        def

demo:
#类名建议大驼峰
class Cat:
        #属性

        #方法
        def eat(self):
                print("猫在吃鱼")
        def drink(self):
                print("猫在喝水")

1-5 创建一个对象
tom = Cat()  #用tom来保存一个对象
定义Cat类
执行Cat()                 #分配了一片内存空间保存Cat
返回对象的引用        #返回内存的地址
tom = 创建的对象的引用#将这个地址复制给tom
#tom就指向了Cat这个对象

1-6 调用对象的方法
tom.eat()
tom.drink()

1-7添加属性
#给tom指向的对象添加两个属性
tom.name = "Tom"
tom.age = 40
#没有括号,在tom这个对象里面添加两个属性,就是两个变量

1-8获取对象的属性
#获取属性的第一种方式
print("%s 的年龄是:%d"%(tom.name,tom.age))
#可不可以定义一个方法,将print()放进去

#获取属性的第二种方式
class Cat:
        #属性

        #方法
        def eat(self):
                print("猫在吃鱼")
        def drink(self):
                print("猫在喝水")
        def introduce(self):
                print("%s 的年龄是:%d"%(tom.name,tom.age))
调用这个方法:
        tom.introduce()
#就直接打印出来了

lanmao = cat()
lanmao.naem = "蓝猫"
lanmao.age = 10
lanmao.introduce()
#但是introduce里面却是tom.name和tom.age的,而不是lanmao的。这里应该写一个更通用的,而不是特定的。这个时候改成self
class Cat:
        #方法
        def eat(self):
                print("猫在吃鱼")
        def drink(self):
                print("猫在喝水")
        def introduce(self):
                print("%s 的年龄是:%d"%(self.name,self.age))

lanmao.introduce()
self 指向了自己

1-9 self 的注意事项:
tom.introduce() 并没有传递参数进去
def introduce(self):
        #self可以改成任何一个参数的名字,但是一定要保证这个方法里面至少有一个参数,并且这个参数是第一个,这个是用来传递当前这个对象的
调用时:tom.introduce() 就相当于 tom.intorduce(tom)
#但是不能自己传,这是python解释器自动传的。通用方式就是写self,但是也可以用其他的。

特别注意  特别注意        特别注意
下划线前后都是两根,一共四根
下划线前后都是两根,一共四根
下划线前后都是两根,一共四根

1-10 __init__()方法
class Cat:
        """定于了一个Cat类"""
        def eat(self):
                print("猫在吃鱼")
        def drink(self):
                print("猫在喝水")
        def introduce(self):
                print("%s 的年龄是:%d"%(self.name,self.age))
#创建了一个对象
tom = Cat()
tom.eat()
tom.drink()
tom.name = "Tom"
tom.age = 40

lanmao = cat()
lanmao.naem = "蓝猫"
lanmao.age = 10
lanmao.introduce()

#希望在创建类的时候,就将属性值给添加上
#在类的定义里面,再定义一个方法 :def __int__(self)

class Cat:
        """定于了一个Cat类"""
        #初始化对象,用来完成一些默认的设定
        def _init_(self):


        def eat(self):
                print("猫在吃鱼")
        def drink(self):
                print("猫在喝水")
        def introduce(self):
                print("%s 的年龄是:%d"%(self.name,self.age))

创建对象的流程:
<1>常见一个对象
class Cat:
        def __init__(self):
                pass
tom = cat()
开辟一个新对象的存储空间

<2>python解释器自动调用 __init__() 方法
在执行 cat() 的时,未赋值给tom之前
self 会将刚创建的对象(就只开辟了一个空间,还不叫tom时)的引用传给 __init__() ,这个时候还没有创建对象tom,调用 self 的时候,会让 self 指向这个对象。
self 指向了这个新定义的对象,于是,我们就可以通过 self 对对象进行一些初始化。

<3> 返回创建的对象的引用给tom

__init__() 方法也被成为魔法方法

1-11 初始化对象属性
class Cat:
        def __init__(self):
                self.name = "Tom"
        #但是每个对象的name可能不一样,这时候考虑再传一个参数进去。
               
#                 |
#                 |
#                \|/
class Cat:
        def __init__(self,new__name,new__age):
                self.name = new__name
                self.age  = new__age

#__init__(self,new__name,new__age)
         new__name
         new__age
         这两个参数的传递:
tom = Cat("Tom",40)
lanmao = Cat("lanmao",10)
#__init__的第一个参数是默认的,直接添加后面的两个参数
#函数调用的时候,"Tom",40 参数就传递进去了,
#new__name和new__age,均属于局部变量

1-12 魔法方法二 __str__()
  class Cat:
        def __init__(self,new__name,new__age):
                self.name = new__name
                self.age  = new__age
        def __str__(self):
                pass


lanmao = Cat("lanmao",10)
然后,直接打印  tom 和 lanmao ,会出现的情况:
print(tom)
print(lanmao)
结果:
<____main____.cat object at 0x7febe642c4a8>
<____main____.cat object at 0x7febe643acf8>
打印出来的是在内存中的物理地址

用 __str__() 方法必须加上 return
class Cat:
        def __init__(self,new__name,new__age):
                self.name = new__name
                self.age  = new__age
        #self.name 和 self.age 并不是函数 __init__() 内部的局部变量,而是定义在对象内部的两个变量,所以在 __str__() 函数中也可用。
         def __str__(self):
                return "%s的年龄是:%d"%(self.name,self.age)
        #return 之后,再在创建对象后,使用 print(),就可以将 __str__() 中return的内容打印出来,而不是打印内存空间的地址。

tom = Cat("Tom",40)
lanmao = Cat("lanmao",10)

#通过了魔法方法 __str__() 打印对象的描述信息
print(tom)
print(lanmao)
结果:
Tom的年龄是:40
lanmao的年龄是:10


1-13 全局变量、函数和属性、方法的联系
对象1:
        >属性
        >方法1
        >方法2

对象2:
        >属性
        >方法
        >

面向过程的:
        >全局变量
        >函数1
        >函数2

在一个对象中,方法和方法之间的数据联系,其实是通过了属性。
在对象1中,方法1可以对属性进行修改,方法2又可以使用属性的值。
在面向过程的程序设计中,函数1和函数2之间可以通过return进行数据联系,也可以通过全局变量的设置达到这个目的。
比如在函数1中通过global进行全局变量的修改,在函数2中使用全局变量。
这和属性和方法非常类似。

相同点:共享数据的方法类似。

不同点:
>1全局变量对所有函数可见,没法在一个函数内部屏蔽掉。
>2对象:就相当于再把全局变量和函数打包,全局变量成为属性,函数成为方法。一个对象内的属性和方法的修改并不会影响另一个对象内的属性和方法。

总结:
函数:将一些独立的功能进行封装。
类,对象:把一些函数的功能和相关的全局变量进行了封装。

1-14 烤地瓜
class SweetPotato:
        
        def __init__(self):
        #描述地瓜的生熟程度
                self.cookedString = "生的"
                self.cookedLevel = 0
                self.condiments = []

        def __str__(self):
                return "地瓜 状态:%s(%d),添加的佐料有:%s"%(self.cookedString,self.cookedLevel,str(self.condiments))
                #视频里讲:self.condiments是一个列表,不能直接用print打印,用str强制类型转换一下,一定就是一个字符串,print打印就没问题了。
                #但是实际发现,可以用print来打印列表啊,去掉str(),效果是一样的。??????????

        #烤的方法
        def cook(self,cooked_time):
               
                self.cookedLevel += cooked_time
                #找到一个当前对象的属性,对其进行修改
                if self.cookedLevel >=0 and self.cookedLevel<3:
                        self.cookedString = "生的"
                        
                elif self.cookedLevel >=3 and self.cookedLevel<5:
                        self.cookedString = "半生不熟"
                        
                elif self.cookedLevel >=5 and self.cookedLevel<8:
                        self.cookedString = "熟了"
                        
                elif self.cookedLevel >=8:
                        self.cookedString = "烤糊了"

        def addCondiments(self,item):
                self.condiments.append(item)

#创建了一个地瓜对象
di_gua = SweetPotato()
print(di_gua)

#添加佐料的位置不影响

#开始烤地瓜
di_gua.cook(1)
print(di_gua)
di_gua.cook(1)
print(di_gua)

di_gua.addCondiments("大蒜")

di_gua.cook(1)
print(di_gua)

di_gua.addCondiments("番茄酱")

di_gua.cook(1)
print(di_gua)

di_gua.addCondiments("孜然")

di_gua.cook(1)
print(di_gua)
di_gua.cook(1)
print(di_gua)
di_gua.cook(1)
print(di_gua)
di_gua.cook(1)
print(di_gua)
di_gua.cook(1)
print(di_gua)
#不断地烤,想办法将cooked_time累加起来
#不能放在已经存在的三个方法中,因为方法一结束,值就没了
#这个时候就该用属性。
#用 self.cookedLevel 来对cook_time 进行累加


#看看地瓜的生熟程度


1-15 存放家具

'''
问题:视频里面有说,print不能打印列表,但实际上是可以打印的,咋回事?
'''

class Home:
        def __init__(self,new_area,new_infor,new_addr):
                self.area = new_area
                self.infor = new_infor
                self.addr = new_addr
                self.left_area = new_area
                self.contain_items = []
        def __str__(self):
                '''
                return "房子的总面积是:%d;可用面积是:%d;户型是:%s;地址是:%s"%(self.area,self.left_area,self.infor,self.addr)
                '''
                #太长了
                msg = "房子的总面积是:%d\n可用面积是:%d\n户型是:%s\n地址是:%s\n"%(self.area,self.left_area,self.infor,self.addr)
                msg += "当前房子里的物品有:%s\n"%(self.contain_items)
                return msg

        def add_item(self,item):
                #当我们添加物品时,就应该让房子的可用面积减少
               
                #self.left_area -= item.area #当前物品的面积
               
                #当前物品的面积在另一个类里面,怎么得到当前物品的面积
                #当前物品就是item,item就指向的床这个对象。床里面有两个属性,需要得到床里面的area属性
                #思路:当我们在创建了一个对象之后,可以给它再添加属性,操作方法是(参考猫的那个属性添加):tom.name = "Tom"
                # tom.age = 40
                #这说明可以通过 对象名.属性 = ""  的方法创建对象属性。既然可以创建,那么类似的在任何地方读取一个对象的属性的方法也可以是 对象名.属性,即:item.area
               
                #self.contain_items.append(item.name)

                #第二种方式:
                #将item.area换成一个方法 item.get_area()
                # get : 应该是床的一种能力
                #get_area:得到床的area
                #get_contain_items:得到床的类型
                #这时候应该在床的类里面定义一种方法
                self.left_area -= item.get_area()
                self.contain_items.append(item.get_name())
                #通过在床里面定义方法的这种操作,使得在房子里面获取床的信息的操作可控,可以在床的方法get_area和get_name 里面进行权限限制,根据情况返回信息。


class Bed:
        def __init__(self,new_name,new_area):
                self.name = new_name
                self.area = new_area

        def __str__(self):
                return "床的类型:%s\n床的面积是:%d\n"%(self.name,self.area)

        def get_area(self):
                return self.area
        def get_name(self):
                return self.name

fangzi = Home(129,"三室一厅","666号")
print(fangzi)

#买家具放进去
#放床,创建一个对象:床,需要定义床的类
bed1 = Bed("床1",4)
print(bed1)
#创建床之后,将床放进房子里面
#把床放进房子的功能,应该是在房子的类里面还是床的类?
#床不会自己搬,应该是房子具有容纳床的这样一个功能,故应放在房子的类里面
#现在就是一个类里面调用另一个类


fangzi.add_item(bed1)
print(fangzi)
#调用对象fangzi里面的功能add_item将床房间fanzi里面去。
#放了床,房子的可用面积减少
#放了床,房子里面应该有一个属性来保存房子里面存放的物品。于是在房子的类里面添加一个默认属性self.contain_items = []

bed2 = Bed("床2",6)
fangzi.add_item(bed2)
print(fangzi)

回复

您需要登录后才可以回帖 登录 | 立即注册