阿祥Python自学笔记

①重点是分支图

②③了解内存

8bit（单位）=1字节

1024字节=1k

1024k=1M

1024M=1G

了解进制  二 、八、 十、 十六

以及进制转换   十进制--》二进制    倒除法—》余数逆序  即为结果

④二进制 —》十进制

八进制—》二进制  例如65是两位数，一位数留三个位置 共---，---六个位置，再用8421法确定六个位置数。5=4+1 所以101    0的位置为8421法2的位置，高位0不要。6也是如此110，所以65—》110101

十六进制—》二进制 例如a4(a为10)一位留四个位置  ----，---- 10除以2倒除法 看倒过来的余数顺序即为前四个空答案1010（也可以用8421法）4也是用8421法算得0100，结果10100100

二进制—》八进制  就是三位数转化为一位数  逆向思维8421法

例11110101—从后往前分割三位 101—》5，110—》6,11不够三位往前填0—》011—》3

二进制—》十六进制（0123456789abcdef） 也是如此 四位转一位（从后往前截四位）

数据存储最小单位是字节，存储数据，最高位1表示负数，0表示正数，例1010四个字节

00000000000000000000000000001010（4字节*8bit=32位，+1）

10000000000000000000000000001010（32位，-1）

⑤安装成功Pycharm

⑥交互模式    cmd命令窗口win+R   输入python，启动python，exit()退出交互模式

Print为python输出函数  输出双引号之间的内容 ，例如print(“zkx is a handsome boy.”)

                                                  -------------2020.3.17    21.55

⑦注释多行需要在注释内容上下+三个单或双引号

如果想执行多条命令—》只需要在同一个print下用逗号（，）隔开，但是需要在每个命令+双引号   遇到逗号会运行一个空格

代码规范：逗号后 、加减乘除前后+空格  为了美观

 

⑧input()输入—》等待人工输入内容—》最好设置语言提示

 

输入的内容保存在age中

Python数据类型（字符串类型）：number数字（整数、浮点数、复数）、string字符串、boolean布尔值、none空值、list列表、tuple元组、dict字典、set集合

  ⑨

⑩

删除后变量无法引用，会报错

Numb1 = int(input(“请输入第一个数：”))

Numb2 = int(input(“请输入第二个数：”))

Print(“numb1 + numb2=” ,  numb1+ numb2)

   

int的作用是将输入的3和4（字符串）转化为数字

查看变量类型   print(type(numb1))

 

int表示就是数字类型的字符串

查看变量地址   print(id(numb1))

 

1. 整数三种定义形式：

 

                      

浮点数用代码计算会有误差  变量表示f1  f2

1. 数字类型转换:

Print(int(1.9))—》转化为整数1

Print(float(1))—》转化为小数1.0

Print(int(“10”))—》转化为整数10

Print(float(”1.1”))—》转化为小数1.1

数学功能：

abs:返回数字绝对值

 

Max:返回参数的最大值

 

Min返回参数最小值

求x的y次方

Print(pow(2,5))—》2^5

四舍五入

Print(round(3.456))—》3

Print(round(3.456, 1))—》保留小数后一位 3.5

Print(round(3.456, 2))—》保留小数后两位 3.46

13.导入库—》import 库—》import math—》导入数学库

数学库一些功能：

向下取整

print(math.floor(18.1))—》18

向上取整

Print(math.ceil(18.1))—》19

返回整数部分和小数部分

Print(math.modf(22.3))—》(0.3000000000007,22.0)

开平方

Print(math.sprt(16))—》4.0

  随机数库  import random

从序列元素中挑选一个元素

Print(random.choice[1,3,5,7,9])

Print(random.choice(range(5)))—》[0,1,2,3,4]

Print(random.choice(“boy”))—》[b,o,y]

练习：产生1—100随机数

r1=random.choice(range(100))+1

Print(r1)

另外方法：
print(random.randrange(1,100,2))

这种方法从1—99（奇数），随机,包含1但不包含100，步长为2，所以最小的奇数为3

起始值是1，步长为1(默认不写)，随机数集合是1—99

起始值是1，步长为2，随机数集合是奇数

起始值是2，步长是2，随机数集合是偶数

随机生成[0,1)之间的小数

Print(random.random())

将序列所有元素随机排序：

import random

list = [1,2,3]

random.shuffle(list)

print(list)

随机生成一个实数[a,b](包括小数、整数):

Print(random.uniform(a,b))

14.算术运算符：+    -    *   /   %(取余)   **(求幂)   //(取整)   

算术运算表达式（进行相关符号的数学运算）：1 + 1    2*3

赋值运算符  =

赋值运算表达式格式:   变量=表达式

其功能：计算等号右侧 表达式的值，并赋值给左侧的变量

复合运算符：+=     a+=b    —》a=a+b

            -=

            *=      \=    %=    **=    //=

if语句格式：

if (空格)表达式：       —》 if 表达式：       

(四个空格)语句         —》    语句

其逻辑：计算表达式的值，如果为真，执行下面语句，假，跳过if语句往下

假：0  0.0  空字符串  None  False  除了这些值，就是真

15.彩票中奖代码：

import random

num1=random.choice(range(2))

num2=int(input("请输入一个数字："))

if num2 == num1:

    print("恭喜你中奖了!")

else:

    print("再接再厉!")

“==是判断语法”

练习：输入一个整数，判断是否是偶数

 

练习2：水仙花数   153=1^3+5^3+3^3

num1=int(input("请输入一个三位数："))

a=num1 // 10 // 10                    #确定三位数的千位

b=num1 // 10 %10                    #确定三位数的十位

c=num1 %10                         #确定三位数的个位

num2=pow(a,3)+pow(b,3)+pow(c,3)      #水仙花数的公式

if num2==num1:                      #if语句

    print("是水仙花数")

else:

    print("不是水仙花数")

练习3：回文数11111   12321   122221

num1=int(input("请输入一个五位数："))

a=num1 % 10

b=num1 // 10 % 10

c=num1 // 10 // 10 // 10 % 10            #可以//1000

d=num1 // 10 // 10 // 10 //10            #可以//10000

if a==d and c==b:                      #条件并列用and

    print("是回文数")

else:

print("不是回文数")

另一种方法：

num1=int(input("请输入一个五位数："))

a=num1 % 10

b=num1 // 10 % 10

c=num1 // 10 // 10 // 10 % 10

d=num1 // 10000

if a!=d:

    print("不是回文数")

if c==b:

    print("是回文数")           两个方法判断一个事物是不是成立的时候，可以拆分方法

练习4：从控制台输入两个数，输出最大的数

num1=int(input("请输入一个数："))

num2=int(input("请输入另外一个数："))

max=num1

if num1

    max=num2

print("max = ", max)

练习5：从控制台输入3个数，输出最大的数

num1=int(input("请输入一个数："))

num2=int(input("请输入另外一个数："))

num3=int(input("请输入第三个数："))

max=num1

if num1

    max=num2

if num3>max:

    max=num3

print("max =", max)

遇到比较时，可以先设定一个最大值，再去进行比较。

1. 位运算符：把数字看作二进制进行计算

&   按位与运算符        上下都为1，下面结果为1，不都为1，则是0，所以101为5。

|    按位或运算符    上下有一个为1，下面就是1。

^    按位异或运算符  上下不同时，结果为1。

~    按位取反运算符  =-6   每个二进制数据位取反（补码与原码）

                                                          2020.4.1  19.58

17.<<  >>   左右移运算符  各二进制位全部左/右移动若干位，由右侧数字决定，高位丢弃，低位补零/高位补零，低位丢弃

左：print(2<< 2) ——》00010——》01000

右：print(13>>2)——》000001101——》000000011

关系运算符和关系运算表达式（if判断）

==  !=  >  <    >=   <=

表达式：表达式1  关系运算符  表达式2

其功能：计算表达式的值

值：真或假  如果关系成立，为真；不成立，假。

逻辑运算符：

或——》or ——》表达式1  or 表达式2——》有一个表达式为真总体逻辑为真

与——》and——》表达式1 and 表达式2——》有一个表达式为假总体逻辑是假（0为假）

非——》not——》not  表达式——》颠倒黑白

If not 1:

Print(“####”)      1为真，整体逻辑非为假，则不会打印

短路原则：“或 、非” 会有表达式罗列长串，原则是从头一个一个判断，遵从笔记上面的结论

18.成员运算符：

In：如果在指定序列中找到值返回True,否则返回False

not in:如果在指定序列中没有找到值返回True,否则返回False

身份运算符：

Is   :判断两个标识符是不是引用同一个对象

Is not:判断两个标识符是不是引用不同的对象

运算符优先级：

**

~  +  -  (正负号  一元加减)

*  /  %  //

+  -       (加减)

>>  <<

&

^  |

<=   <   >   >=

==    !=

=  %=   +=  -=

Is   is not

In   not in

not   or  and

逻辑符练习：从控制台输入一个年份，判断是否为闰年（能被4整除且不能被100整除  或被400整除）

 

19.什么是字符串：是以单引号和双引号括起来的任意文本,字符串不可变！

 

字符串运算：

    sunck  is  a  good  man

  goodgoodgood

  查找出“u”

截取字符串的一部分;

截取“zkx”——》  Str1=”zkx is a good man!”

Str2=str1[0:3]   或  Str2=str1[:3]

Print(“Str2=”, Str2)

截取“is a good”——》Str2=Str1[4:13]

                     Print(“Str2,” Str2)

过程：4对应i ,空格也算一位字符串，d对应12，但是需要往后加一位！

中间截取到结尾：str2=str1[2:]

判断某个数据是否在一堆数据里：

Str1=”zkx is a good man”

Print(“good” in str1)          ——返回True

格式化输出（多个不同类型值输出+占位符）：
print(“num = %d, str = %s, f = %.3f” % (num, str ,f))

%d（整数）、%s（字符串）、%f（浮点数）占位符

1. 上节课的占位符输出是一行输出，如果想分行输出，如下：

Print(“num = %d\nstr =%s\nf =%f”%(num,str,f))    在分行部分逗号换“\n”

转义字符   \  （将一些字符转换成特殊含义的字符）

如果单纯想打出 \n ,需要敲\\n,转义成一个\n的意思

Print(‘asd is a ‘good’ man’)会产生语法错误，需要＋\ 把good前后的单引号转义成文本单引号（双引号也成立）  print(‘asd is a \’good\’ man’)

如果字符串里有多行，用\n不好阅读，方法如下：

结果

如果字符中有好多字符串都需要转义，就需要加入好多\,为了简化，python允许用r表示内部的字符串默认不转义，如下：

 

处理字符串的方法：

①eval(“字符串”)     功能：将字符串str当成有效表达式来求值，并返回计算结果

Print(eval(‘12+3”))   结果 15

21.②len(“字符串”)      功能：返回字符串的长度（字符个数）

Print(len(“ss sss ddd”)) 结果：10  （空格也算字符串）

③lower()            功能：转换字符串中大写字母为小写字母

Str1=”ASD AD”

Print(str1.lower())   结果：asd ad

④upper()            功能：转换字符串中小写字母为大写字母

Str1=”asd ad”

Print(str1.upper())      结果：ASD AD

⑤swapcase()         功能：转换字符串中小写字母为大写字母，大写转小写

Str1=”asd AD”

Print(str1.swapcase())     结果：ASD ad

⑥capitalize()         功能：只有首字母是大写，其他字母为小写

Str1=”asd AD”

Print(str1.capitalize())     结果：Asd ad

⑦title()

Str1=”asd ad”         功能：每个单词首字母大写

Print(str1.title())         结果：Asd Ad

⑧center(宽度，”填充物”)  功能：在字符串前后填符号,不写，默认空格填充

Str1=”asd ad”

Print(str1.center(40，”*”))    结果：**********asd ad***********

补充：char=character    字符类型

⑨ljust(宽度,”填充物”)    功能：字符串左对齐

Str1=”asd ad”

Print(str1.ljust(40，”*”))          结果：asd ad**************

⑩rjuet(宽度,”填充物”)    功能：右对齐

Str1=”asd ad”

Print(str1.rjust(40,”*”))     结果：************asd ad

22.①zfill(宽度)   zero       功能：左侧零填充

Str1=”asd ad”

Print(str1.zfill(40))     结果：000000000asd ad

②count(“某单词”, 范围头，尾)       功能：返回字符串中某单词出现的次数，可以指定一个范围，范围不写默认是从头到尾

Str1=”asd ad ad”

Print(str1.count(“ad”,4,6))     结果：1

③find(“某单词”,范围头，尾)   功能：从左到右检测某单词是否包含在字符串中，可以指定范围，默认从头到尾，得到的是第一次出现所调查单词的下标，如果在指定范围没有，返回-1

str1=”asd ad”     

print(str1.find(“ad”))     结果：4

④rfind(“某单词”,范围头，尾)   功能：从右到左检测某单词是否包含在字符串中，可以指定范围，默认从头到尾，得到的是第一次出现所调查单词的下标，如果在指定范围没有，返回-1

str1=”asd ad ad”     

print(str1.rfind(“ad”))     结果：7

⑤index(“某单词”,范围头，尾)    功能：跟find一样，只不过如果某单词不存在的时候回报一个错误

str1=”asd ad ad”

print(str1.index(ad))     结果：4

⑥rindex(“某单词”,范围头，尾)    功能：跟rfind一样，只不过如果某单词不存在的时候回报一个错误

str1=”asd ad ad”

print(str1.rindex(ad))    结果：7

⑦lstrip(“指定字符”)     功能：截掉字符串左侧指定的字符，默认为空格（）

str1=”        asd ad”     

print(str1.lstrip(“指定字符”))    结果：asd ad

⑧rstrip(“指定字符”)     功能：截掉字符串右侧指定的字符，默认为空格（）

str1=”asd ad            ”     

print(str1.rstrip(“指定字符”))    结果：asd ad

⑨strip(“指定字符”)     功能：截掉字符串两侧指定的字符，默认为空格

str1=”asd ad”     

print(str1.strip(“指定字符”))    结果：asd ad

以后开发，不要相信别人给的数据里没有空格，用此方法！

⑩split(“str”, num)    以str为分隔符截取字符串,指定num,则仅截取num个字符串

Str=”as     ad  af”

Print(str.split(“*”))              结果：[‘as’,’’,’’,’’,’ad’,’af’]

   另一种方法判断多少单词

①splitlines(keepends)        按照(‘\r’,’\n’,’\r\n’ )分隔

Keepends==True   按行切割为list，会保留换行符

 

②”连接风格”.join(seq)     将seq中字符串拼接

 

 

③max()  min()

 

最小的是空格（按照ASCII比较）

④replace(“要替换的”,”替换成什么”，num)    替换，默认是全部替换，如果指定num,那么只替换前num个

 

 

以上为常用！

⑤startswith(“给定字符串”，范围开始，范围结束)    在给定范围内，判断是否是以给定字符串开头，默认整个字符串

     返回：false

⑥endswith(“给定字符串”，范围开始，范围结束)       在给定范围内，判断是否是以给定字符串结尾，默认整个字符串

 

⑦encode(encoding=”utf-8”,errors=”strict”)     编码

 

         b为二进制格式保存

⑧decode()     解码要与编码时的编码格式一致     （视频35）

 

            

⑨isalpha()    如果字符串中至少有一个字符且所有字符都是字母，返回True,否则返回False

 

⑩isalnum()      如果字符串中至少有一个字符且所有字符都是字母或数字，返回True,否则返回False

    返回：True

①isupper()      如果字符串中至少有一个英文字符且所有字符都是大写英文字母，返回true,否则返回false

 

②islower()      如果字符串中至少有一个英文字符且所有字符都是小写英文字母，返回true,否则返回false

       

③istitle()    如果字符串是标题化的返回true

   返回：true

     返回：false

   返回：false

④isdigit()     如果字符串只包含数字字符，返回true

     返回：true

⑤isnumeric()       同上

⑥isdecimal()    字符串只包含十进制字符

⑦isspace()     如果字符中只包含空格，返回true

返回：true

  都返回true

1. while循环语句结构：

whlie 表达式：

    语句

逻辑：当程序执行到while语句时，首先计算表达式的值，如果表达式的值为假，那么结束整个while语句。如果表达式的值为真，则执行语句，执行完语句，再去计算表达式的值........（循环如此直到为假才停止）

例子：打印1-5

num=1

while num<=5:

Print(num)

num=num+1

例2：计算1+2+3+.......+100的值

 注意：最后一行print必须顶格，否则会打印100次sum的值

例3：打印字符串

 

作业：补充知识   

Ascll值（每个字符串存入电脑内存的数字   例a=97）

查找某字符的Ascll值-------print(ord(“所需要查找的字符”))

查找某Ascll值所代表的字符-------print(chr(某Ascll值))

Print(“a”==”a”)--------返回True

Print(“a”!=”a”)---------返回False

①打印所有三位数中的水仙花数

a=100

e=0

while a<1000:

    b=a%10

    c=a//10%10

    d=a//100

    if b**3+c**3+d**3==a:

        e+=1

    a+=1

print(e)

②五位数中有多少回文数

num1=10000

e=0

while num1<100000:

    a = num1 % 10

    b = num1 // 10 % 10

    c = num1 // 10 // 10 // 10 % 10

    d = num1 // 10000

    if c==b and a==d:

        e+=1

    num1+=1

print(e)

③从控制台输入一个数，判断是否为质数

 

 

break一旦符合条件，终止循环，执行下面语句

④从控制台输入一个数，分解质因数

 

⑤从控制台输入一个字符串，返回字符串有多少单词

str=(input("请输入一句英文："))

num=1

index=0

while index < len(str):

    if ord(str[index])==32:

        num+=1

    index+=1

print("num = %d"%(num))

⑥从控制台输入一个字符串，打印字符串中所有数字字符的和

str="zx1c2vb33n4m"

index = 0

sum=0

while index < len(str):

    if str[index] >="0" and str[index]<="9":

        sum=sum+int(str[index])

    index += 1

print(sum)

1. 字符串比较大小规则：从第一个字符开始比较， 谁的Ascii值大谁就大，如果相等会比较下一字符ASCii值得大小，谁值大谁就大，如果前面一样，谁长谁大

Print(“aab” < ”aac”)   返回True

Print(“aasd” > “aas”)    返回True

布尔值与空值：一个布尔值只有True和False两种值

b1=True

b2=False

Print(b1,b2)       结果：True False

空值：是python特殊的值，用None表示。 None不能理解为零，因为0是有意义的，而None是一个特殊值。（面向对象，引用对象）

25.-------------------------list(列表)------------------------

思考：存储100人的年龄

解决：用列表（有序的集合）

创建列表格式;

列表名=[列表选项1，列表选项2，... ...，列表选项n]

创建一个空列表：

liet1 = []

print（list1）

创建带有元素的列表：

list2=[1,2.3,4]

列表不同类型的数据：

list=[1,”asd”,True]

列表元素的访问：

  取值格式：列表名[下标]

           list = [1,2,3]

           print(list[2])      返回：3

 

  替换格式：list[2] = 300

            Print(list)       返回：[1,2,300]

           注意：不要越界！！

例子：计算五个人平均年龄

list1=[1,2,3,4,5]

index=0

sum=0

while index<5:

    sum+=list1[index]

    index+=1

print("平均年龄 =%d"%(sum/5))

层级的嵌套最好不要超过三层，多了就看不懂了。

列表操作：

①列表组合

     

②列表的重复：

        

③判断元素是否在列表中：

   

④截取

      

二维列表：

list1=[[1,2,3],[4,5,6],[7,8,9]]

Print(list1[1])                  返回：[4,5,6]

Print(list1[1][1])                返回：5

列表方法：

①append()    在列表末尾添加新的元素

List1=[1,2]

List1.append(6)       返回：[1,2,6]

List1.append([7,8,9])   返回：[1,2,6,[7,8,9]]

Print（list1）

②extend()       在末尾一次性追加另一个列表中的多个值

list1=[1,2]

list1.extend([7,8,9])

print(list1)               返回：[1,2,7,8,9]

1. ③insert(坐标，添加元素)      在下标处添加一个元素，不覆盖原数据，原数据顺延

List1=[1,2,3,4,5]

List1.insert(2.100)       结果：[1,2,100,4,5]         

List1.insert(2,[200,300])    结果：[1,2,[200,300],4,5]

④pop(坐标)        删除表中指定下标元素，默认最后一个，同时返回删除的数据

List1=[1,2,3,4,5]

List1.pop()      结果：[1,2,3,4]    5

List1.pop(2)  结果：[1,2,4,5]     3

⑤remove(4)    移除列表中的某个元素的第一个

List1=[1,2,3,4,5,4]

List1.remove(4)

Print(list1)               结果：[1,2,3,5,4]

⑥clear(清除列表中所有数据)

List1=[1,2,3,4,5,4]

List1.clear()

Print(list1)               结果：[]

开始查找，所以方法前要重新定义变量（往下）：

⑦index(某个查找值，范围开始，范围结束)    从列表中找出某个值第一个匹配的下标值

List1=[1,2,3,4,5, 3,4,5,6]

A=List1.index(3)          结果：2  

A=List1.index(3,3,7)       结果：2  5

Print(A)        

⑧len()      列表中元素个数

List1=[1,2,3,4,5,4]

Print(len(list1))            结果：6

⑨max()   min()         访问最大值    最小值

List1=[1,2,3,4,5,4]

Print(max(list1))

⑩count()       查看查询值的次数

List1=[1,2,3,4,5,4]

Print(list.count(3))     返回：1

⑩删除列表中某个值，包括重复

 

注意：list.count(3)  不能当做while语句的条件，因为下面的remove语句伴随一次循环删除一次3的值，造成列表长度缩短

27.①reverse()         将列表倒过来

List1=[1,2,3,4,5,4]       

List1.reverse

Print(list1)

②sort()       升序排序

List1=[1,3,5,4]

List1.sort()

Print(list1)

③ 浅拷贝：引用拷贝

      

 

List27和list28 是一个变量

④深拷贝：内存拷贝

 

 

      

⑤将元组转成列表

  

⑥找出第二大的值

 

 

1. 29.分解质因数（略）

条件控制语句：

if语句   

If else语句

If-elif-else语句格式：

If 表达式1：

  语句1

elif 表达式2：

    语句2

elif 表达式3：

语句3

...........

else:       ————可有可无

   语句e

逻辑：略

*每个elif都是对它上面所有表达式的否定！

30.死循环：表达式永远为真的循环

While-else 语句格式：

while 表达式：

     语句1

else:

     语句2

逻辑：在条件语句（表达式）为False时，则执行else中的语句2

for语句格式：

for 变量名 in 集合：

语句

逻辑：按顺序取集合中的每个元素赋值给“变量”，再去执行语句。如此循环往复，直到取完“集合”中的元素为止

      

range()函数     列表生成器   生成数列

for x in range(10):

   Print(x)          结果：0....9

for x in range(2,20,2):      2是开始，20终止后的一位数，2为步长

   Print(x)          结果：2,4，....20

同时便利下标和元素：

for index, m in enumerate[1,2,3,4,5]:        index,m=下标，元素   enumerate为枚举生成器

   Print(index,m)       

 结果：     

例:1+2+3+..........100

 

注意：for的使用比while多，while能办到的for也能办到，for更清晰。

1. break语句：

作用：为了跳出for和while循环,后面不执行!

注意：只能跳出距离它最近的那一层循环!

例子：

for i in range(10):

   print(i)

   If i==5:

     break

continue语句：

作用：跳过当前循环中的剩余语句，然后继续下一次循环

注意：只跳过最近的循环

   结果：

While语句中，“+=”需提前！

作业：

打印99乘法表

 

输入两个数，求这两个数的最大公约数

 

输入一个字符串，将字符串中的大写转小写，小写转大写

 

随机生成一个6位数的验证码

Turtle模块绘图：简单的绘图工具提供一个小海龟，理解为一个机器人，只能听懂有限的命令,绘图从正中间开始，默认向右（俯视）。

运动命令：

turtle.forword(d)      向前移动d长度

turtle.backward(d)     向后移动d长度

turtle.right(d)         向右转d度

turtle.left(d)

turtle.goto(x,y)   移动到x y步

Turtle.speed(d)   速度d运动

笔画控制命令：

turtle.up()      笔画抬起，不会绘图

turtle.down()     笔画落下，开始绘图

turtle.setheading(d)     改变海龟朝向d度

turtle.pensize()       笔画宽度

turtle.pencolor(“颜色”)     改成颜色

turtle.reset()       清空窗口，重置turtle状态

turtle.clear        清空窗口，不会重置

turtle.circle(r,e)     绘制一个圆形，r为半径，e为次数成为一个圆(steps=5五边形)

turtle.begin_fill()     #以下皆为颜色填充

turtle.fillcolor(“颜色”)

turtle.circle(50,steps=5)

turtle.end_fill()

其他命令：

turtle.done()    程序继续执行

turtle.undo()   撤销上一次动作

turtle.hideturtle    隐藏海龟

turtle.showturtle   显示海龟

turtle.sreensize(d,d)   绘画屏幕规模

Import turtle

作业：

正方形

 

矩形

 

正方体

 

五角星

 

奥运五环

 

围棋棋盘

 

国际象棋棋盘

1. 元组：一种有序集合

特点：与列表非常相似

一旦初始化就不能修改

使用小括号

创建空的元组：

tuple = ()

Print(tuple)

创建带有元素的元组,元素类型可以不同：

Tuple=(1,”good”,True)

定义只有一个元素的元组：

Tuple=(1,)

Print(tuple)

元组元素的访问：

格式：元组名[下标]   下标越界报错

①获取最后一个元素：

Print(tuple[-1])

②修改元组  元组里面的元素不能变，如果里面有列表，列表可以变

Tuple=(1,2,3,4,[5,6,7])

Tuple[-1][0]=500         

Print(tuple)             结果：(1,2,3,4,[500,6,7])

③删除元组

del  tuple

元组的操作：

①元组相加

 

②元组重复

 

③判断元素是否在元组中

    True

④元组的截取

格式：元组名[开始下标：结束下标]   *截取结束下标之前！

   

 

⑤二维元组:元素为一维元素的元组

 

元组的方法：

①len()  返回元组中元素的个数

②max((元组元素))   最大值

③min((元组元素))   最小值

④将列表转元组

 

能用元组用元组，安全，元组不可变！

1. 字典--dict1={ “tom”:60,”aym”:70}

注意：字典是无序的

概述：使用键-值(key-value)存储，具有极快的查找速度。

Key的特性：
1.字典中可以存储多个键值对，key必须唯一

1. key必须是不可变得对象
2. 字符串、整数都是不可变的，可以作为key
3. List是可变的，不能作为key
4. 字符串作为key最多

思考：保存多位学生姓名与成绩--使用字典，学生姓名作为key，成绩作为值

元素的访问：
①获取：字典名[“key”]

Print(dict1[“tom”])       返回：60    没有的会报错

没有的值不想让它报错(常用)：

Print(dict1.get(“sunck”))   返回：None

 

②添加：

dict1[“hanmei”] = 99

Print(dict1)       

返回：

再添加一个重复的：会修改，因为一个key只能对应一个value,多次对一个value赋值，其实就是修改值

③删除：

dict1.pop(“tom”)

Print(dict1)

1. 遍历：

①

   

②

  

③

    

跟第一个一样结果，但是这个好点

④

  

字典是无序的

与List列表比较：

1. 查找和插入的速度极快，不会随着key-value的增加而变慢
2. 需要占用大量的内存，内存浪费多

List列表特点：

1. 查找和插入的速度随数据增多而减慢
2. 占用空间小

练习：

W=input()

d={}

 

    #转化为一个列表

 

结果：

 

次数：

 

逻辑：

1. 以空格切割字符串
2. 循环处理列表中的每个元素
3. 以元素当做key去一个字典中提取数据
4. 如果没有提取到，就以该元素为key,1作为value存进字典
5. 如果提取到，将对应的key的value修改，值加1
6. 根据输入的字符串当做key再去字典取值

1. 时间下一秒：

        

39.歌词解析：

40.set：类似dict，是一组key的集合，不存储value。用的做多的和其他数据进行数据转换，进行去重

本质：无序和无重复元素的集合

创建：需要一个list或者tuple或dict作为输入集合

S1=set([1,2,3,4,5，3,4,5])

Print(s1)          结果：{1,2,3,4,5}

重复元素在set中会自动过滤（列表、元组、字典不会打印值）。

添加：add()

添加重复的，但是没效果；不能添加列表和字典

列表不能作为key，set存的就是key；key不能用可变对象，list是可变对象。

打碎插入整个list、tuple、字符串：

S1=set([1,2,3,4,5])

S1.update([6,7,8])

Print(s1)              结果:{1,2,3,4,5，6,7,8}

 

 

删除：remove(想删哪个元素，不按照下标)

S6=set([1,2,3,4,5])

S6.remove(3)

Print(s6)      结果：{1,2,4,5}

遍历：

S7=set([1,2,3])

For i in s7:

   Print(i)         结果：1  2  3  

如果按照下标提取元素，会报错（字典也没下标）
交集：

      

并集：

          

类型转换：

①List—》set   上面创建已经展示

②Tuple-》set   跟list一样

③Set—》list

  

④set—》tuple      跟上面一样

⑤去重

    

 

1. 可迭代对象：可以直接作用于for循环的对象（iterable）,可以用isinstance()去判断一个对象是否是可迭代对象

可以直接作用于for的数据类型一般分两种:

1. 集合类数据类型：list、tuple、dict、set、string
2. 是generator，包括生成器和带yield的generator  function

判断可迭代对象前需要引入库：from collections import iterable

 返回：True

迭代器（iterator）：不但可以作用于for循环，还可以被next()函数不断调用并返回下一个值，直到最后跑出一个StopIteration错误，表示无法继续返回下一个值，可以使用isinstance()函数判断一个对象是否为iterator对象。

需要导入库：from collections import iterator

模型：

多了一个x，即生成迭代器，多一个next会报错

各种数据类型转换成迭代器：

引入iter()函数

   结果：1  2

1. 认识函数：在一个完整的项目中，某些功能会反复使用。那么会将这个功能封装成函数，当我们要使用功能的时候，直接调用函数即可。

本质：函数就是对功能的封装

优点：

①简化代码结构，增加了代码的复用度（重复使用的程度）

②如果想修改某些功能或者调试某个BUG（最大的敌人，常态），只需要修改对应的函数即可

定义函数：

格式：

def  函数名(参数”列表”):       

     语句

     return 表达式

#def：函数代码块以def关键字开始

#函数名：一般会遵循标志符规则

#():是参数列表的开始和结束

#参数“列表”：任何传入函数的参数和变量必须放在圆括号之间，用逗号分隔。函数从函

数的调用者那里获取的信息

#冒号：函数内容（封装的功能以冒号开始），并且缩进

#语句：函数封装的功能

#return：用于结束函数，并返回信息给函数的调用者

#表达式：即为要返回给函数调用者的信息

注意：return表达式可以不写，相当于return None

44.定义最简单的函数  myPrint() （无参无返回值）：

 

函数的调用格式：函数名（参数列表）

#函数名：是要使用的功能函数函数的名字

#参数列表：函数的调用者给函数传递的信息，如果没有参数括号也不能省略

#调用函数的本质：实参给形参赋值的过程

函数的参数：参数必须按顺序传递，个数目前要适应，否则报错

需求：编写一个函数，给函数一个字符串和一个年龄，在函数内部打印出来

 

形参（形式参数）：定义函数时小括号中的变量（str,age），本质是变量！

 

实参（实际参数）：调用函数时给函数传递的数据，本质是值！

结果：

 

函数的返回值：

需求：编写函数，实现功能，给函数两个数，返回这两个数的和

 

执行完return语句，该函数就结束了，return后面的代码不执行

45.传递参数：

值传递：传递不可变类型（string，tuple，number）

    结果：20

修改num的值对外面没有影响

引用传递：传递的可变类型（list，dict，set）

结果：[100,2,3,4,5]

修改lis的值对外面有影响

1. 关键字参数：允许函数调用时参数的顺序与定义时不一致

 

默认参数：调用函数时如果没有传递参数，则使用默认参数

以后要用默认参数，最好将默认参数放在最后！

 

不定长参数：能处理比定义时更多的参数

加了星号（*）的变量存放所有未命名的变量参数，如果在函数调用时没有指定参数，它就是一个空元组

例1.

 

 

例2.

  *a是自己定义的值

1. “**”代表键值对的参数字典

 

 结果是字典类型

 

例4.可以传任意参数

 

匿名函数：不使用def这样的语句定义函数，使用lambda来创建匿名函数

特点：

1. lambda只是一个表达式，函数体比def简单
2. Lambda主体是一个表达式，而不是代码块，仅仅只能在表达式中封装简单的逻辑
3. Lambda函数有自己的命名空间且不能访问自由参数列表之外的或全局命名空间的参数
4. 虽然是一个表达式，且看起来只能写一行，

格式：lambda 参数1，参数2，参数3，...参数N：表达式

 

1. 装饰器：是一个闭包，把一个函数当参数返回一个替代版的函数本质上就是一个返回函数的函数。

简单的装饰器：

 

 

f是func1的加强版本

 

48.复杂一点的装饰器：

 

 

@装饰器   即可省去“func1=outer(func1)”

 

 

通用装饰器：添加任意类型参数

 

 

函数参数理论上使用无限的，但实际最好不超过6、7个

49.偏函数：import functools

base=进制   默认十进制

例如：改成二进制

Int1 = functools.partial(int,base=2)  把一个参数固定住，形成一个新的函数

变量的作用域：变量可以使用的范围

程序的变量并不是在所有位置都能使用的，访问的权限取决于变量在哪里赋值

局部作用域：

全局作用域：

内建作用域：

1. 异常处理

需求：当程序遇到问题时不让程序结束，而越过错误继续向下执行

错误处理的语句：

try......except......else

格式：

try:

语句t

except 错误码 as e:         #错误码就是运行程序栏提示的错误

语句1

except 错误码 as e:

语句2

................

except 错误码 as e:

语句n

else:                       #可有可无

语句e

作用：用来检测try语句块中错误，从而让except捕获错误信息并处理

逻辑：当程序执行到try结构语句时

1. 如果当try语句t执行出现错误，会匹配第一个错误码，如果匹配上，就执行对应的语句
2. 如果当try语句t执行出现错误，没有匹配的异常，错误将会被提交到上一层的try语句，或者到程序的最上层
3. 如果当try语句t执行没有出现错误，执行else语句下的语句e

分步捕获错误码：

 

错误代码从网上找

使用except而不使用任何的错误类型：

 

使用except捕获多种异常：

 

1. 特殊：

1. 错误其实就是class(类)，所以的错误都继承自BaseException,所以在捕获的时候，它捕获该类型的错误，并把子类一网打尽
2. 跨越多层调用函数，也能捕获错误

try......except......finally

逻辑：语句t无论是否有错误，都会执行最后的语句f

try:

语句t

except 错误码 as e:         #错误码就是运行程序栏提示的错误

语句1

except 错误码 as e:

语句2

................

except 错误码 as e:

语句n

finally:                       

语句f

作用：文件处理，关闭文件

52.53.断言：

def func(num,div):

   assert(div != 0),”div不能为0”

   return num / div

文件读写

读文件过程：

1. 打开文件

open(path,”flag”,encoding=，errors=)

Path:要打开文件的路径

flag:打开方式

r    以只读的方式打开文件，文件的描述符放在文件的开头

rb   以二进制方式打开，只读，文件的描述符放在文件的开头

r+   打开一个文件用于读写，文件的描述符放在文件的开头   

w   打开一个文件只用于写入，如果该文件存在他会覆盖，不存在，则创建一个新文件

wb  打开一个文件只用于写入二进制，如果该文件存在他会覆盖，不存在，则创建一个新文件

w+   打开一个文件只用于读写

a    打开一个文件用于追加，如果文件存在，文件描述符将会放到文件末尾

a+    

encoding:编码方式(utf-8,gdk)

errors:错误处理

 

1. 读文件内容

①读取文件全部内容：

Str1=f.read()

Print(str1)

②读取指定字符数：

Str2=f.read(10)

Print(str2)

③读取整行，包括“\n”字符

Str2=f.readline()

Print(str2)

④读取指定字符数：

Str2=f.readline(10)

Print(str2)

⑤读取所有行，并返回列表

List=f.readlines()

Print(list)

⑥若给定的数字大于0，返回实际size字节的行数

List2=f.readlines(25)

Print(list2)

 

修改描述符的位置：

f.seek(想要重新读的位置)

1. 关闭文件

f.ciose()

一个完整过程：

 

更简便的方法：

 

无论文件打开成功或失败，with都会自动关闭

1. 55.函数也是一种数据类型  f=函数名

写文件：

1.将信息写入缓冲区

f.write(“sun  is  a good  man”)

2.刷新缓冲区（关闭文件、手动刷新、缓冲区满了、遇到\n）

f.flush()   直接把缓冲区数据立即写入文件，而不是等待关闭自动刷新缓冲区写入

简单形式：

 

编码与解码

56.list/tuple/dict/set的文件操作

Import pickle    #数据持久性模块

列表写入文件：(其他也一样)

Mylist = [1,2,3,4,5,”asd”]

Path=

F = open(path,”wb”)

Pickle.dump(mylist,f)

1. close()

读取：

F 1= open(path,”rb”)

Templist=pickle.load(f1)

Print(temlist)

F1.close

Os模块

Import os

Os：包含了普遍的操作系统的功能

获取操作系统类型:  nt-->windows   posix-->linux、unix   

Print(os.name)   返回：nt

打印操怍系统详细信息：(windows不支持)

Print(os.uname())

获取操作系统的所有环境变量：

Print(os.environ)

获取某个环境变量：

Print(os.environ.get(“某变量”))

获取当前目录：

Print(os.curdir)

获取当前工作目录，即当前python脚本所在的目录：

Print(os.getcwd)

以列表形式返回指定目录下的所有文件：

Print(os.listdir(r”文件路径”))

在当前目录下创建新目录：

相对路径：

Os.mkdir(“sunck”)

绝对路径：

 

删除目录：

Os.rmdir(“sunck”)

57.获取文件属性：

Print(os.stat(“sunck”))

重命名：

sunck换kaige

Os.rename(“sunck”,”kaige”)

删除普通文件：

Os.remove(“file1.txt”)

运行shell命令：

Os.system(“notepad”)   打开记事本

Os.system(“write”)      写字板

Os.system(“mspaint”)    画板

Os.system(“msconfig”)

Os.system(“shutdown -s -t”)   关机

Os.system(“shutdown -a”)     注销操作

Os.system(“taskkill /f/im 关闭的软件.exe”)     关闭软件

有些方法存在os模块里，还有些存在于os.path：

查看当前的绝对路径：

Print(os.path.abspath(“./kaige”))

拼接路径：

 

注意：参数2里开始不要有”\”

拆分路径：（拆最后的）

获取扩展名：

 

 

获取文件下一级，先判断是否是目录：

（path2去掉txt）

返回：true

判断文件（没有下一级）是否存在：

 

判断目录是否存在：

 

获得文件大小（字节   一个汉字三个字节）：

 

返回：97   数字

获得文件目录：

 

 

 

获得文件名：

 

1. 控制窗体的显示与隐藏：

（需下载pywin32  spy窗口）

Import win32con

Import win32gui

Import time

#用spy窗口碰撞窗口

#找出窗体的编号

QQwin=win32gui.FindWindow(“spy显示的类”，”窗体标题”)

#隐藏窗体

Win32gui.ShowWindow(QQWin,win32con.SW_HIDE)

#两秒钟后显示

time.sleep(2)

#显示窗体

Win32gui.ShowWindow(QQWin,win32con.SW_SHOW)

#循环窗口，前提是需要提前打开窗体软件

QQwin=win32gui.FindWindow(“spy显示的类”，”窗体标题”)

while True:

    Win32gui.ShowWindow(QQWin,win32con.SW_HIDE)

    time.sleep(2)

    Win32gui.ShowWindow(QQWin,win32con.SW_SHOW)

    time.sleep(2)