大数据菜狗为了实验室重拾python之路

一、continue和break

        continue是跳出当前循环直接进入下一次循环；break是直接跳出当前循环

         注意：continue在使用中必须注意是否会进入死循环的问题（主要看用于控制循环次数的变量在continue语句之前有没有对应的进行更改）

 这种情况是可以进行的

i=0
while (i<10):
    if (i == 3):
        i += 1          #使用continue时需要确认是否会进入死循环
        continue
    print(i)
    i += 1

但如果将continue之前的i+=1去掉的话，continue执行后while就会陷入一个死循环，特别注意

二、print函数的拓展

        print函数默认在输出内容后的结束符是\n，即换行符；而在print中加入end="字符"，即可人为指定输出内容结束后的结束符了；

        print函数它是自带换行符的，也就是说，就算你使用print("\n")，在输出完一个换行之后，print函数又会自动输出一个换行，也就是说print("\n")的输出结果就是两个换行

三、转义字符

        \n为换行符

        \"为转义输出双引号（在print函数中）

        \t在控制台输出一个制表符，协助在输出文本时在垂直方向上对齐

        ex:(九九乘法表）

        未使用转义字符：

row=1
while (row<=9):
    quarry=1
    while (quarry<=row):
        sum = quarry*row
        print("%d*%d=%d"%(quarry,row,sum),end=" ")
        quarry+=1
    print("")
    row+=1

        输出结果：

         使用转义字符作为输出的分隔符：

row=1
while (row<=9):
    quarry=1
    while (quarry<=row):
        sum = quarry*row
        print("%d*%d=%d"%(quarry,row,sum),end="\t")
        quarry+=1
    print("")
    row+=1

        输出结果（对齐）：

四、函数

        ①函数被调用之前需要先定义；

        ②定义函数时需要传参的话，直接定义即可；

        ex:def print_lines(a,b):

                        .......

        ③在pyhton中也可以使用return来返回所需要的值，更加便捷的是，在python中不需要注明函数返回值的类型（不同于c/c++），直接return即可

五、模块

        yysy类似于c/c++中的头文件，但使用起来也有不同的地方；（注意：模块名也必须符合标识符的命名规则）

        ①调用模块中的函数或变量的时候，需要在文件头声明调用该模块：

        ex:import  啥啥啥.py

        ②调用模块中的函数或变量，使用模块.函数名/变量名来调用

        ex:my_circle.print_area()

        

六、列表

        ①列表的定义：用[ ]定义，数据间用","分隔，数据索引从0开始，取值----list[]

        ②列表常用操作：

                Ⅰ .index:用于获取指定内容在列表中的索引，若列表中没有指定值则会报错

                        ex:list.index("...")

                Ⅱ .append:用于向列表的末尾追加数据

                        ex:list.append(".....")

                Ⅲ .insert:用于向列表的指定位置添加数据(通过索引)，插入位置的值就变成指定数据，

                        ex:list.insert(1,"abc")，则索引为1的值就直接变成"abc"，原来的数据均往后挪一位

                Ⅳ .extend:可以将指定列表中的内容追加到列表中

                        ex:templist=["666","777"],name_list=["123"]，name_list.extend(templist) 

                Ⅴ .remove:直接删除列表中的指定数据（遇到多个重复元素时，只能删除第一个元素）

                        ex:name_list.remove("123")

                Ⅵ .pop:若不带参数，则默认将列表中最后一个元素删除；若带参数(索引)，则将指定索引位置的元素删除

                        ex:name_list.pop()  ;  name_list.pop(3)-------删除索引为3的元素

                Ⅶ .clear:清空列表------变成空列表

        ③使用del关键字对列表中的元素进行删除操作

                区别于直接对列表进行的操作（.啥啥啥），使用del关键字删除元素会直接在内存中删除这个变量，后续代码不能够继续使用该变量

        ④len关键字和count关键字

                len:用于计算列表中的元素总数（即列表长度）

                        ex:len(name_list)         

                count :用于统计列表中某个数据出现的次数

                        ex:name_list.count("123")-------------统计name_list中"123"出现的次数

        ⑤对列表的排序（sort和reverse）

                sort:升序/降序排序                参数中有个reverse参数，默认reverse=False--升序，指定reverse=True即对列表进行降序排序

                        ex:list.sort()---升序                list.sort(reverse=True)--降序

                reverse:逆序排序（翻转顺序）

                        ex:list.reverse()---对列表顺序进行翻转

        ⑥迭代遍历（众所周知的for循环）

                for i in list（列表变量）:                -------i获得的是list列表中的各个内容

七、元组

        ①元组的定义、和列表的区别：

                用"()"来定义，元素之间用","分隔，与列表不同的是，元组中的元素是不可修改的

                元组一般用于存储不同类型的数据

                获取元组中对应元素的方法也和列表相同，都是通过索引

                        Ex：info_tuple[0] ------获取索引为0的元素

                注意：定义元组只有一个元素时，需要在这个唯一的元素后面加个","，好让系统知道这是定义一个元素的元组，不然系统会认定这就是个正常的变量

                

infotuple = (8)

print(infotuple)







输出结果：8

        

                ②对元组的操作--------------类比于对列表的操作(.index、.count等等）

                ③对于元组元素的遍历---------------类比于对列表元素的遍历(基本用不到对元组的遍历，因为元组中存储的变量类型基本都不同，所以很难对不同元素执行统一的操作)

                ④应用场景：

                        Ⅰ作为函数的参数和返回值----------一个函数可以通过元组接受任意多个参数，或者一次返回多个参数

                        Ⅱ 格式字符串-------------print("...."%())本质上是一个元组

                        Ⅲ 让列表不可以被修改，以保护数据安全

                ⑤列表与元组之间的转化

                        元组：tuple()----------------转化成元素不能修改的列表

                        列表：list()-------------------转化成元素能够修改的列表

八、字典

        ①字典的定义：

                字典是无序对象（列表是有序）的集合，用键值对来存储数据,通常用于描述一个变量的

                相关信息；

                键（类似于索引）必须唯一，但值可以取任何数据类型（字符串、数字、元组）；

                键和值之间使用":"分隔，键值对之间使用","分隔-------key:value,key:value；

                使用”{ }“定义；

        ②针对字典的常用操作：

                Ⅰ 取值：dict[key]

                Ⅱ 增加 / 修改：dict[key] = value---------------key存在，则修改值；key不存在，则新建键

                值对

                Ⅲ 删除：dict.pop(key)

                Ⅳ 统计键值对数量：len(dict)

                Ⅴ 合并字典：dict1.update(dict2)--------合并后的字典就是dict1

                如果dict1和dict2中有相同的键，那么dict2的对应键的值会覆盖掉dict1的对应键的值

                Ⅵ 清空字典： dict.clear()

        ③对字典的循环遍历

                for k in dict:-----------------------k是每一次循环中从字典中取出来的key

        ④字典的应用场景

                字典使用多个键值对来描述一个物体的相关信息，可以将多个字典放在一个列表中，再

                进行遍历，在循环体内部针对每个字典进行相同的处理

                ex：

stu_list = [{"name":"ljh","age":18}
    ,{"name":"jx","age":19}]

for info in stu_list:
        print(info)

输出结果
{'name': 'ljh', 'age': 18}
{'name': 'jx', 'age': 19}

                

九、字符串

        ①字符串的基本操作

               Ⅰ 统计字符串长度：len()
                Ⅱ统计某一个子字符串出现的次数：.count(),出现不存在的子字符串的是次数为0
                Ⅲ某一个子字符串出现的位置.index(),若该子字符串不存在则会报错
        ②字符串的常用方法总览和分类(.啥啥啥)
            1.is'''判断类型
                isspace ()：若字符串中只包含空格或其他制表符等空白字符，则返回True
                isdecimal ():若字符串中只包含数字，则返回True,不能判断小数(返回False)
                isdigit ()：除了只有数字之外，像只有(1)这种unicode字符串也能返回True
                isnumeric():除了上述两个判断数字的功能它都有之外，他还能判断中文数字(一二三四五这些，有且只有则返回True
            2.查找与替换    
                 startswith():检查字符串是否以指定字符串开始
                 endswith():检查字符串是否以指定字符串结束
                 find():查找指定字符串出现的索引(类似于index,但如果使用find 来查找不存在的字符串，返回的索引值是-1，不会报错)
                replace (old,new):用新的字符串替换旧的字符串，返回值是原字符串替换后的新字符串，但并不会对原字符串做出改动

              3.文本对齐

                center(width,filtter_char)：使字符串居中对齐，width是指居中的字符串宽度，filter_char是指填充字符

                      ex:      

poem = ["静夜思","床前明月光","疑是地上霜","举头望明月","低头思故乡"]

for i in poem:
    print(i.center(10," "))

输出结果：

   静夜思    
  床前明月光   
  疑是地上霜   
  举头望明月   
  低头思故乡   

                 ljust(width,filter_char)：向左对齐  ||||||  rjust(width,filter_char)：向右对齐

               4.去除字符串中的空白字符

                       strip()：去除掉字符串左右两边的字符串

                       lstrip()：去除字符串左边的空白字符

                       rstrip()：去除字符串右边的空白字符 

               5.字符串的拆分和连接

                       str.split('char',num)：将字符串按照指定分隔符(char)进行拆分，拆分的结果放入一个列表-----即返回值是一个列表,num代表分割次数。如果未指定分隔符，则默认空白字符(空格、制表符、换行符这些)为分隔符对字符串进行拆分

                       char.join(list)：将list中的所有元素合并为一个新的字符串------即返回值是一个字符串，元素之间的分隔符为char

        ③字符串的切片

                字符串[开始索引:结束索引:步长]

                步长是指有间隔的跳跃性切片，例如name[1:8:2]，就是从索引1开始，每隔两个取一个元素（1后面就取3），到8截至（不包括索引8的元素）

               ⭐ 切片的方法是前闭后开，即开始索引的元素是包含在内的，但结束索引的元素是不包含在内的

                ex：

name = "peace world"
print(name[0:5:])

输出结果：peace

                实用方法 ：

                1.顺序第一个元素的索引是0，倒序最后一个元素的索引是-1（往前就是-2...）

                        可以从正往负切片------和正向切片一样的效果（name[2:-1]就是从第三个元素到倒数第二个元素）

                2.如果想要将最后一个元素切进来，那么只需要将结束索引的位置空出来即可

                        Ex：name[0::]-----------------将所有元素切出来

               3.如果想要从第一个元素开始切，可以直接将开始索引为空-----name[:]---所有元素

               4.如果想逆序切片，则可以将步长改为-1------name[-1::-1]----字符串逆序

⭐十、公共方法（字典、列表、元组、字符串）

                ①python内置函数

                        Ⅰlen（）--------计算元素个数

                        Ⅱ del（）--------删除变量

                        Ⅲ max（）------返回容器中元素的最大值（如果是字典，则只针对key进行比较）

                        Ⅳ min（）------返回容器中元素的最小值（如果是字典，则只针对key进行比较）

                        Ⅴ 比较运算符(>,<,==)来比较元组、字符串、列表的大小（字典是无序的，不能比较）

                ②切片（只针对列表、元组、字符串）-----------参照字符串切片

                ③运算符

                        Ⅰ*----重复拼接（字典除外）

                        Ⅱ +---合并（字典除外）

                        Ⅲ in/not in----成员运算符

                                判断元素是否在容器内---in(在返回True)、not in(不在返回True)

                                字典在使用成员运算符的时候针对的是key

                ④完整的for循环语法

                        for 变量 in 集合:

                                代码

                        else:

                             没有通过break退出循环，循环结束后会执行的代码（执行完for里面的语句后）

                        应用场景：查找容器中是否有对应元素，若没有则可以得到一个统一的提示（else后的代码）

                                ex:查找有无姓名为ljh的学生

stu = [{"name":"ljh"},{"name":"cxy"},{"name":"szh"}]

for i in stu:
    if i["name"] == "ljh":
        print(i)
        break
else:
    print("没找到名为ljh的学生")

      

⭐return的作用 

        return可以返回一个函数的执行结果，下方的后续代码不会被执行，如果说return后面没有任何内容，那么就直接返回到调用函数的位置

        Linux上的shebang符号(#!)
        能够直接运行(./),前提是文件有可执行权限，通过#!+解释器完整路径

十一、变量进阶

        ①变量中记录数据的地址，叫做引用，可以通过id()来查看数据的地址
        ②调用函数时，传递到函数里面的是实参保存数据的引用，而不是实参保存的数据
        ③函数返回值的时候，返回的是数据的引用，而不是数据本身

        可变类型与不可变类型
                不可变类型：
                   数字
                   字符串
                   元组
                可变类型：
                   列表
                   字典
        对列表/字典中的值使用方法进行修改，列表/字典的内存地址不会发生变化
        字典中的key只能使用不可变类型的数据：

        hash是一种算法，接受一个不可变类型的数据作为参数，返回结果是一个整数，作用就是提取数据的特征码-----相同的内容得到相同的结果，不同的内容得到不同的结果（类似于指纹），在建立字典时，pytho会对字典的key进行hash操作，以确定key是唯一值，因此，字典中的key必须是不可变类型的参数

       局部变量和全局变量

                局部变量：

                        临时保存函数内部需要使用的数据。在调用函数时被创建，函数执行结束后被系统回收

                全局变量：

                        在函数内部不允许修改全局变量的引用，即不能在函数中使用赋值语句直接对全局变量进行修改；全局变量一定要定义在调用函数之前，尽量直接定义在函数的上方

                       而如果需要在函数内部修改全部变量的值，可以使用global关键字

                        ex:

number = 10

def count():
    global number
    number = 99
    print(number)

count()
print(number)


输出结果：
99
99

        十二、返回值进阶

                需求：一个函数需要返回多个结果，可以将元组作为返回值（将元组作为返回值时，它的小括号可以省略），得到的返回值中的多个元素可以使用索引（[ ]）将对应数据提取出来，或者使用多个变量依次接收（变量个数应该与元组中的元素个数保持一致）-------这种方法也可以用于变量之间的值的交换：    a,b=b,a         将a,b的值进行交换，等号右边是个元组

                ex:（rec1，rec2）

import math
tmp = int(input("请输入一个整数："))

def deal_num():
    return math.pow(tmp,2),tmp+1

rec1,rec2 = deal_num()
print("%d的平方是：%d，%d+1=%d"%(tmp,rec1,tmp,rec2))

输出结果：
请输入一个整数：10
10的平方是：100，10+1=11

十三、函数的参数

        1、如果传入的参数是个可变类型（列表、字典）的数据，在函数中对该数据使用了方法改变了其中的元素，会影响到该变量的具体值（对于+=符号，这个符号对列表来说就相当于.extend()方法，因此对列表使用+=符号也会影响到具体值  ，但对于不可变类型的变量是不会影响的（因为+=就相当于num =num+...，而这个是赋值语句），而直接在函数中使用list = list+ anlist是不会印象到具体值的，因为这也是赋值语句）

        2、 缺省参数：（就是c里面的默认参数）

                没有实参传进来就使用默认值，有就传参（直接=）；所有带有默认值的缺省参数都要保存在参数列表的末尾

        3、多值参数：

                有事需要一个函数能够处理的参数个数是不确定的，就可以用多值参数

                1、参数名前加一个*可以接受元组     eg:*args，变量名为args

                2、参数名前加两个*可以接受字典     eg:**kwargs（字典赋值要用=号），变量名为kwargs

                3、拆包：当调用含有多值参数的函数时，若希望将一个元组变量直接传递给args，将一个字典变量直接传递给kwargs，就可以在元组变量前加一个*，在字典变量前加两个*

num_tuple = (1,2,3,4)
name_dict = {"name":"ljh","age":18}

def show_num(*args,**kwargs):
    print(args)
    print(kwargs)

show_num(*num_tuple,**name_dict)

                ex:

              

输出结果：

1
()
{}
1
(2, 3, 4)
{}
1
(2, 3, 4)
{'name': 'ljh', 'age': 18}

十四、函数的递归

        定义：一个函数内部调用自己
        特点：

        1.函数内部代码相同，只是针对参数不同，处理的结果不同
        2.当参数满足一个条件时，函数不再执行(递归出口)
                理解：先假定该函数能够实现n之前的功能，直接用一个变量来接受已经假定的功能和本数 

                ex：

十五、面向对象

        类只有一个，对象可以有很多个，对象的属性和方法可以不同，可以通过dir()查看对象的属性和方法
        _方法名_都是Python提供的内置方法/属性
        ⭐定义 只包含方法的类：
                class 类名：
                      def 方法(self,参数):------第一个参数必须是self
                        pass

        创建对应对象：对象名=类名()

        对于给某一个对象临时增加属性，可以直接tmp.attribute = ...，但是这种方法不推荐，因为非常不安全（封装性堪忧）

        self参数：就是调用方法的对象本身；

        ⭐初始化方法：

                为对象的属性设置初始值------初始化方法（__init__)

                ex:

                     

             __del__方法：对象从内存中销毁时自动调用（类似于析构函数）

             __str__方法：使用print函数输出对象时，输出自己指定的内容（通过返回字符串来实现）

                ex：def __str__(self):        return "这是一个字符串"                print(ljh）---ljh是个对象