python3.5及以上入门笔记(一)--------基础知识

添加小程序，兑换各种视频教程/数据资源。

(一)前言：

1. IDLE：python学习的外壳，即通过键入文本与程序交互的途径。、

2. 在python官网下载python到本地，在电脑左下角开始->搜索找到IDLE打开，即可看到编译软件。参考：https://jingyan.baidu.com/album/0bc808fc42dfab1bd485b99f.html?picindex=3。

hbuilder运行python参考：https://blog.csdn.net/u011662047/article/details/51568911。

3. 基础：print("welcome python")           ,表示打印输出里面的语句，主要python3.0之后不支持print "welcome python"和 printf("welcome python");    2种写法都不支持，报错。 #在python中表示注释。dir(_bulitins_)查看python的内置函数(bif)，help(big)查看某个内置函数的解释说明，type(a)查看a的类型，isinstance(a,str/int/float)判断a的类型是否是字符串/整数/浮点型，返回true/false。ctrl+n进入IDLE的编译入口，即之编译不执行，再保存后按F5或者点击run即可执行编译好的代码块。alt+n下一条编译语句，alt+p上一条编译语句。 

，

(二)基础语法：

1. python支持的数据类型：数字型(包括整型int，浮点型float，复数complex和布尔型)和非数字型（String(字符串)，List(列表)，Tuple(元组)，Sets(集合)，Dictionary(字典)）；

2.整型int：包括正，负整数，没有限制大小，支持+、-、*、/法则。注意：在整数除法中，（/）计算的结果是浮点数（即使能整除也至少保留一位小数）如151/51 结果为3.0,（//）表示只取结果的整数部分，如200//51  结果为3。

3. 浮点型float：有小数点，或者科学计数法表示。支持+、-、*、/法则。注意：在计算机中整型和浮点型存储方式不同，整数的运算永远是精确的，浮点型运算可能会有四舍五入的误差，如3.3*102 结果为352.0999999999997,且浮点型在四则运算下结果都为浮点型。

4. 复数complex：即有实数部分和虚数部分组成，a+bj或complex(a,b)表示复数，其中a、b都是浮点型。

5. 数据类型的转换：int(x) ：x转换为整数，即去整数部分，单是只能转换数值类型或者纯数字的字符串类型，否则报错。float(x)：x转换为浮点型。complex(x)：x转换为复数，实数部分x，虚数0。complex(x,y)：x为实数部分，y为虚数部分。str(x)：x转换为字符串，str(5e10) 其结果为"5e10"。

6. 常量：全部大写的变量名，如PT（圆周率）和E（自然常数）。

7. 转义：转移字符\或者在字符串前加r'这是字符串，里面的特殊符号会被转义'。注意用r转义时，字符串最后一位不能是\。对于很多行的字符串，需要用三引号"""，如"""    这里是一段小诗     """  。注意：单双引号都是英文的。

8. 模块： import random, 引用random模块， random.randint(1,10)调用random模块中的randint()方法，随机生成1~10的整数。

             以.py结尾的文件，就是模块。引入模块：import random 。 调用模块的方法 :random.randint() 

9. 算术操作符：+、-、*、/、%、**（幂运算）、//（除取下整）。

10.比较操作符：>、<、>=、<=、==、！=，判断两个变量的值（不是内存地址）是否相等。

11.赋值运算符：=、+=、-=、*=、/=、%=，**=、//=。

12.位运算符：&、|、^、~、<<、>>。

13.逻辑操作符：and 、or、not。

14.成员运算符：in、not in。

15.身份运算符：is、is not，判断俩个对象的内存地址是否想到。

16.优先级：幂运算>正负符号>算术运算符>比较运算符>逻辑运算符。

17.查看变量在内存的地址：id(a)，就是查看变量a在内存的地址，如14656。

18.修改全局变量：在函数内部global num声明该函数内的num是全局变量，然后可以修改全局变量num了。否则在函数内部不能修改全局变量。注意：全局变量的定义，通常在所以函数的最上面（前面）。全局变量的命名，为了区分局部变量，可以在前面加gl_，如gl_name。如果一个函数内执行某个全局变量，如果该全局变量的声明在函数执行（不是函数的定义，是函数的执行）之后，就会报错，因为代码是从上向下执行的。

num='我是全局变量'
def changeNum():
    print(num)  #这里是获取全局变量
    
    global num
    num='我是global修改的全局变量'
    
    print(num) #修改后的全局变量

    print(name) #此时报错，因为name声明在函数执行之后。

changeNum()

name='放在changeNum函数执行之后的全局变量'

19. 在hbuilder编译器中怎么编译.py文件：https://blog.csdn.net/u011662047/article/details/51568911；

18. 变量： 无需声明，直接赋值，全部大写字母可以表示常量也不需要声明， teacher="我是变量值，被赋值给前面的teacher变量"，变量的命名，由数字，字母，_组成，数字不能再首位，且不能是关键词。在使用变量前 需要进行赋值。命名规则：驼峰命名法，匈牙利命名法，下划线命名法。注意，在使用变量之前，一定要对其赋值。

20.查下关键字：

import keyword  #导入关键字模块
print(keyword.kwlist)  #打印关键字模块

(三)列表和元祖：

1.序列（即非数字型）：包括列表，元祖，字符串，列表，字典。序列的操作如下：

         ① 索引：即下标，通过索引获取单个元素，a[0]。正向从0开始，反向从-1开始，列表，元祖，字符串，列表支持索引，字典没有索引。

         ② 分片：获取一定范围的元素组成的序列，a[start:end:step]，含start不含end，step默认1，不位0，负数表示反向取值。字典不支持切片，列表，元祖，字符串，列表支持切片。

         ③ 序列拼接：通过'+'返回新的序列，字典不支持，列表，元祖，字符串，列表支持拼接。

         ④ 乘以数字：序列*数字，返回，重复数字遍的新序列。如'a'*3='aaa'，字典和整数不支持，列表，元祖，字符串，列表支持乘以数字。

         ⑤ 判断成员资格：in、not in。列表，元祖，字符串，列表，字典都支持。

         ⑥ 常用api：len(a)，max(a)，min(a)，del(a)。列表，元祖，字符串，列表支持常用api，注意：在字典中max()和min()方法，是针对字典的key进行大小比较的，字典支持del。

2.列表：列表的元素类型，可以是不同类型的，如[1,'a',[3],true]，列表也可以比较大小，如[1,1,1]<[2,2,2]，除了以上序列的操作方法，还有如下操作：      

         ① 元素索引赋值：通过索引修改元素的值，list[0]="修改列表下标为0的值"。但是，不能为不存在位置赋值。

         ② 增加元素append：list.append(obj),向列表尾部添加obj元素。

         ③ 删除元素del：del list[1],删除页列表指定下标对应的元素。

         ④ 列表化对象list()：将字符串转换为列表;

         ⑤ 分片插入：list[2:2]="这列表2位置插入该值"。

         ⑥ 嵌套列表：[[1,2],3,4]。

         ⑦ 列表方法：

                  ⑴  append：list.append(obj)，在列表尾部添加元素，修改原列表。

                  ⑵  count：list.count(obj)，元素obj在列表中出现的次数。

                  ⑶  extend：list.extend(obj)，在列表尾部追加另一个序列的多个值，修改原列表。

                  ⑷  index：list.index(obj)，从列表中查找第一个匹配项obj的索引位置。

                  ⑸  insert：list.insert(index,obj)，在列表指定位置，插入指定元素。

                  ⑹  pop：list.pop(i)，移除列表中指定位置的元素，并返回该值，默认不写i，是移除最后一个元素。

                  ⑺  remove：list.remove(obj)，移除列表中第一个出现obj值的元素。

                  ⑻  reverse：list.reverse()，列表倒叙。

                  ⑼  sort：list.sort(func)，列表排序。

                  ⑽  clear：list.clear()，清空列表，相当于del list[:]。

                  ⑾  copy：list.copy()，复制列表，相当于list[:]。

list_arr=['a','b','c','d']

print(list_arr[1])          #索引：列表的索引下标，默认从0开始
list_arr.append('e')          #添加：列表末尾添加'e'
list_arr.insert(0, '开始')  #插入：在列表指定位置0处插入‘开始’
list_arr.extend(['f','g','h'])    #拓展：在列表尾部拓展['f','g','h']

list_arr.remove('f')      #删除：列表删除指定元素'f'第一次出现时被删除，即存在多个'f'时，删除从左向右第一次出现那个，注意，如果删除不存在的元素，会报错，
list_arr.pop(index)     #删除：不写Index,默认删除列表的最后一个，否则删除指定索引index对应的元素
del list_arr[index]     #删除：删除列表指定索引对应的元素
del list_arr            #删除：删除整个列表
list_arr.clear()        #清空：清空列表

len(list_arr)           #长度：列表的长度
list_arr.count('f')     #统计次数：统计某个元素在列表中出现的次数。因为列表的元素，是可以重复的

list_arr.sort()        #升序：列表的升序
list_arr.sort(reverse=True)  #降序：列表的降序
list_arr.reverse()      #倒序

3.元祖：内容不能改变的列表，空元祖()，只有一个元素的元祖(1,)，而(1)解释器会识别为int类型，元祖也可以比较大小，如（1,1,1）<（2,2,2），。    

         ① tuple()：函数是讲序列转换为元祖。

         ② 索引访问元祖：tuple[i]，查找元祖下标i的值。

         ③ 拼接元素：通过'+'返回新的元祖。

         ④ 删除元祖：del tuple，只能删除整个元祖，不能删除元祖里面的某个元素。

         ⑤ 分片元祖：tuple[1:]。

         ⑥ len(tuple1)：元祖长度，max/min(tuple)，元祖里最大最小值。

         ⑦ 交换2个变量的值：a,b=(b,a)，其中()可以省略。另外一种交换变量值的方式，a=a+b,b=a-b,a=a-b;

         ⑧ index：tuple.index(val)，查看元祖中元素val的索引。

         ⑨ count：list.count(val)，查看元祖中元素val的出现的次数。

info=("Ace",70,175) #元祖
print("%s的身高%d,体重%d"%info)
info_str="%s的身高%d,体重%d"%info
print(info_str)

(四)字符串：

1.字符串：由单/双引号构成，支持序列的索引，分片，成员资格，长度，最大最小值。但是不支持分片赋值。

2.转义字符：

3.字符串格式化：使用'%'完成字符串格式化操作。

     

 

print("阿哲今年%s岁"%'27')。

print("%s今年%s岁"%("Ace",'27'))。

4.字符串的api方法：

         ① find()：str.find(str1,start=0,end=len(str)),查找字符串str中从索引start开始到end结束的子字符串str1第一次出现的位置，找到返回该位置，找不到返回-1。不写start和end默认查找整个字符串。

         ② join()：str.join(sq),将序列sq中的元素，通过字符str（如'+',','等）拼接成新的元素。注意，str和sq里面的元素都必须全是字符串，否则报错，即'+'.join([1,2])会报错。

         ③ lower()：str.lower(),不需参数，将字符串str全部大写转换为小写。

         ④ upper()：str.upper(),不需参数，将字符串str全部小写转换为大写。

         ⑤ swapcase()：str.swapcase(),不需参数，将字符串str中小写转换为大写，小写转换为大写。

         ⑥ replace()：str.replace(old,new[,max]),将字符串str中的old子字符串替换为new字符串，不写max参数，表示替换所有的old，有max参数表示最多替换max次old。

         ⑦  split()：str.split(str1="",num)将字符串切片成列表,str是切割符，默认是空格，num表示切割几次，默认是该切割符

存在的次数。

         ⑧  strip()：str.strip(chars)，去掉字符串首尾的chars字符（如'---'），默认不写是空格/空白字符。

         ⑨  center()：str.center(10[,chart])，宽度为10的文档居中对齐显示，参数chart是填充的参数，默认是英文的空格。

         ⑩  ljust()：str.ljust(10[,chart])，宽度为10的文档向左对齐显示，参数chart是填充的参数，默认是英文的空格。

         ⑾  rjust()：str.rjust(10[,chart])，宽度为10的文档向右对齐显示，参数chart是填充的参数，默认是英文的空格。

(五)字典：

1. 字典：即由一对键值对组成的，键必须是唯一的，key键的类型可以是字符串，整数，元祖，但是不能为列表/元祖类型，即字典的key必须是不可变类型(字符串，整数，元祖),不能是可变类型（列表/元祖），字典与字典之间不能比较大小。

2. 通过key键获取值：dict1[k]。

3.通过key来修改/新增键值：dict1[key]=val，如果key存在就是修改Key值，否则就是新增key值对。

4.for循环遍历字典：for k in dict1:  print(k,dict1[k])。

5. 字典的方法：

           ① len()：len(dict1)查看字典键值对个数。

           ② clear()：dict1.clear()，清空字典。

           ③ update()：dict1.update(dict2)，合并键值对。

 

(六)条件、循环和其他语句：

1.文件名：智能是字母，数字，下划线组成。

2.import的使用：import module1[,module2,module3]  从python标准库中引入单个或多个模块。import math as m,为模块取别名。

3.from modname import name1[,name2,name3]/*：从指定模块中引入其中的部分函数,*表示引入模块中所有。  from math import pi as p,取别名。

4.使用逗号输出：print("a","b","c")

5.赋值：

       ① 序列解包：如x,y,z=1,2,3，相当于x=1,y=2,z=3赋值。注意：左边的x,y,z和右边的1,2,3数量必须相等，否则报错。

       ② 链式赋值：如x=y=z=10。

       ③ 增量赋值：如*=、+=、-=、/=、//=、%=、**=。

6. 条件语句：

       ① if 条件表达式：

                 #满足条件表达式时，执行的代码，需要缩进。

           elif 条件表达式：

                #满足条件，执行的代码。

           else:

               #else执行的代码。

       ②  嵌套代码：即if条件语句里面还有嵌套if语句。

       ③  is的同一性运输符：x is y与x==y，前者是判断x和y是否指向同一内存地址，后者判断x和y值是否相等。

7. 循环：

       ①  while 条件表达式/True:

                 #执行循环体

                 break    #跳出循环

                 countinue  #跳出当前循环进入下一次循环

       ②  for item in seq:     #循环任何序列，包括字符串，列表。for key,value in tuple1.items():  循环字典。注意：字典是无序的。for num1,num2 in zip(range(3),range(100)),zip函数以短序列range(3)为准长度，当短序列遍历结束，for循环就会结束。num1,num2分别对应序列range(3)和range(100)的元素。for item in 

        ③  sorted(seq)：倒序排列序列，并返回列表。如seq=[1,2,3]或seq='hello,world!'。

        ④  reversed(seq)：倒序排列序列，并返回与原序列同类型，如字符串，列表，就返回倒序后的字符串，列表。

        ⑤  pass：空语句，保持程序结构的完整性。

        ⑥  例如九九乘法表：

                

 

(七)函数：

1. 对代码的封装：重用，优化代码，对有参数的函数，参数类型不对，数量不对也会报错。

2.函数的声明：

          def 函数名(参数):

                #要执行的函数体，必须缩进（没有缩进代码可以用pass代替），没有return或者return(return None)表示返回值都是None。函数可以返回一个元祖，如return (val1,val2)，其中()可以省略，即return val1,val2。 可以通过result=函数名()，执行返回的结果，即result[0]=val1，result[1]=val2。或者用a,b=函数名()，执行返回的结果，即a=val1，b=val2。

3.函数的参数：

        def fun(name,age=27):

              #调用函数fun时，传入的参数方式，fun("Ace",27)或fun(name="Ace",age=27)，在声明函数def fun(age=27)表示默认参  数值为27，默认参数，又叫缺省参数，注意无论多少个默认参数，默认参数都不能在必须参数之前。如不能def fun(age=27,name)：会报错。对于不确定参数个数的用*arg表示未知参数个数，对于参数是字典的未知元素个数，用**arg。组合参数顺序：def  fun(p,dval,**arg)。注意：函数的必须先定义，才能提前，不能声明提前。

4.函数的执行流程：从上倒下，从左到右。

5.形参和实惨：

6.变量的作用域：局部作用域，全局作用域。

7.递归函数：函数内部调用函数自身，注意：一定要有终止条件，避免死循环。

8.匿名函数：调用完就在内存中清除的函数。

         lambda x,y:

              return x+y

9.函数的注释：

         def fun():

                 """这是函数的注释"""

                print("关于函数的注释")

10.多值参数：

          def fun(num,*args,**kwargs):   一个*表示接收不确定个数的元祖，俩个**表示接收不确定个数的字典参数.

                 print(num)     

                 print(args)     

                 print(kwargs)

         fun(1,2,3,4,name="Ace",age=28)  :其中num=1,*args=(2,3,4),可以循环元祖，求元祖所有值的和，**kwargs={name="Ace",age=28}

11. 元祖（*实参）和字典（**实参）的拆包：     fun(*tuple1,**dict1)。     

    def fun(*args,**kwargs):   一个*表示接收不确定个数的元祖，俩个**表示接收不确定个数的字典参数.

                 print(args)

                 print(kwargs)

    tuple1=(1,2,3)

    dict1={name="Ace“，age=27}

    fun(tuple1,dict1)   #执行该函数时，会将tuple1,dict1实参全部划分给形参*args，而**kwargs则为空字典。即打印args出来(1,2,3),{name="Ace“，age=27} 以及kwargs打印出来{}。

     fun(*tuple1,**dict1)  #执行该函数时，会将tuple1实参划分给形参*args，而实参dict1划分给**kwargs。即打印args出来(1,2,3) 以及kwargs打印出来{name="Ace“，age=27}。

 

 

面试题：1.a=5，b=6，交互2个变量a和b的值。

解法一：c=a，a=b，b=c。

解法二：a,b=b,a。元祖解法。

解法三：a=a+b，b=a-b，a=a-b。