1. #replace()函数：将从左到右替换指定的元素，可以指定替换的个数，默认全部替换
   
   my_string = 'hello_world'
   my_string.replace('_',' ')

   输出为：'hello world'

2. #insert()函数，可以指定位置添加元素，如果指定下标不存在，就在末尾添加
   list1 = ['小','夫','猪','吗','?']
   list1.insert(2,'是')
   list2 = ''.join(list1)    #''.join可以将列表转换成字符串
   print(list2)

    

   输出为：小夫是猪吗?

3. #format()一种格式化输出方式
   
   name = 'jiejie'
   team = 'EDG'
   hight = 180
   score = '冠军打野'
   
   print('大家好！我叫{},我来自{}战队,我的身高是{.1f},我在S11的成绩是{}。'.format(name,team,hight,score))

         输出为：大家好！我叫jiejie,我来自EDG战队,我的身高是180.0,我在S11的成绩是冠军打野。

#一种可读性更好的方法 f-string
#可以将上面最后一行代码改为

print(f"大家好！我叫{name},我来自{team}战队,我的身高是{hight:.1f},我在S11的成绩是{score}.")

#输出结果同样为：大家好！我叫jiejie,我来自EDG战队,我的身高是180.0,我在S11的成绩是冠军打野. 

           4.  列表生成式

#比较繁琐的生成式：
list_1 = [1,2,3,4,5]
for i in range(len(list_1)):
    list_1[i] += 1
print(list_1)  

输出为：[2, 3, 4, 5, 6]


#更为简洁的生成式方法为：
[n+1 for n in list_1]  

#同样输出为：[2, 3, 4, 5, 6]

#还可以在生成式中添加生成条件，在条件成立的情况下，才执行for遍历
[n+1 for n in list_1 if n%2==0]

输出为：[2,4,6] 

       5.

#在list_A 但是不在list_B中
list_A = [1,3,6,7,32,65,12]
list_B = [2,6,3,5,12]
[i for i in list_A if i not in list_B]

输出为：[1, 7, 32, 65]

      6.

# 字符串中所有以'sv'结尾的
#endswith（）函数:取字符串末尾
list_2 = ['a','b','c_sv','d','e_sv']
[s for s in list_2 if s.endswith('sv')]  #if 后面的条件成立的话，才会返回S的值

      7.  关于生成器，yield和return的区别（这个思考了好久，不容易理解）以举例子来帮助自己记忆

#程序开始执行以后，因为foo函数中有yield关键字
#所以foo函数并不会真的执行，而是先得到一个生成器g(相当于一个对象)
#同样的，yield 只能在函数中使用
def foo(num):
        print("starting...")
        while num<10:
            num=num+1
            yield num
for n in foo(0):
    print(n,end = ',')

输出为：
starting... 1,2,3,4,5,6,7,8,9,10,

      8.

split()函数，可以将字符串，按照指定的内容分割并生成列表的形式

my_string = 'hello_world'
my_string.split('_')


输出为：['hello', 'world']

 

  函数部分

参数的传递
（位置参数）
位置参数是最简单的一种函数调用的方式。位置参数须以正确的顺序传入函数、数量必须和声明时的一样。

def student_name_and_age(name, age):
    print('姓名：%s 年龄 %s' %(name, age))
student_name_and_age('张三', 18)

输出为：姓名：张三 年龄 18

 

（缺省参数）：调用函数时，缺省参数的值如果没有传入，则被认为是默认值。

def student_name_and_age(name, age='不愿透露'):
    "设置默认参数"
    print('姓名：%s 年龄 %s' %(name, age))
student_name_and_age('张三')

输出为：姓名：张三 年龄 不愿透露

（可变参数）：允许传入的参数为0或者任意多个，且在函数调用自动祖闯为一个tuple（元组）

def student(names):
    for name in names:
        print('姓名：',name,end = '')
names = ('小夫'，'小张'，'小得')
print（student（names））
 

输出为：姓名：小夫，小张，小得

 

 

（关键字参数）允许传入的参数为0或者任意多个，且在函数调用自动祖闯为一个dict（字典）

（1）：参数中（*）表示接收参数为元组，（**）表示接收参数为字典

 

def student_info(name, age, kw,**h):
    print(f'我的名字叫：{name}\n年龄：{age}\n身高：{kw}\n地址：{h}')
    if 'c' in h:
        print('来自：',h['b'])
student_info('张三', 18, 180, c='广东',b='上海')

     输出为：

我的名字叫：张三
年龄：18
身高：180
地址：{'c': '广东', 'b': '上海'}
来自： 上海

 

（参数的组合）

但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。

 

def student_info(name, age=18, *books, city, **kw):
    # 如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了：
    print('我的名字叫：', name, '年龄：', age,'其它信息：',kw)
    print('来自:',city)
    for book in books:
        print('我有{}书'.format(book))
student_info('张三', 18, '语文','数学','计算机', city='北京', height=180, weight=75)

      输出为：

我的名字叫： 张三 年龄： 18 其它信息： {'height': 180, 'weight': 75}
来自: 北京
我有语文书
我有数学书
我有计算机书

 

变量的作用域和global变量

1.局部变量 作用域:在函数内

2.全局变量 作用域:在函数外

函数优先使用局部变量 在没有局部变量的情况下， 使用全局变量

try:
    # 定义在函数内部的变量，函数结束之后自动消亡
    def get_my_name():
        new_name = '赵四'
    get_my_name()
    new_name
except NameError as e:
    print('new_name没有被定义')

    这里使用了异常的处理，函数内变量会自动消亡，这样就会出现报错。输出为：new_name没有被定义

 

   lambda匿名函数：是一个表达式函数

int2str = lambda x : str(x)
int2str(5)

输出为：'5'

    高阶函数：函数的名字也可以作为一个变量，传入其它函数

 

def func_x(x, f):
    return f(x)
func_x(-1, abs)  #将-1传给x,将abs()这个绝对值函数传递给参数f，相当于表达式abs(x)

输出为：1

 

 

# 一个更复杂的例子
def func_xy(x, y ,f):
    return f(x,y)

add = lambda x,y : x+y 
mul = lambda x,y : x*y 
SS = lambda x,y : x**2 + y**2
print(func_xy(1,2,add))
print(func_xy(1,2,mul))
print(func_xy(1,2,SS))

输出为：

3

2

5

 

map/reduce

map()函数接收两个参数,一个是函数,一个是Iterable,map将传入的函数依次作用到序列的每个元素,并把结果作为新的Iterator返回。

fx = lambda x:x**2
ls = [1,2,3,4,5,6,7,8,9]
rst = map(fx,ls)
print(list(rst))

       输出为：[1, 4, 9, 16, 25, 36, 49, 64, 81]

reduce（）: 用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，依此类推，最后得到一个结果

from functools import reduce
mul_xy = lambda x,y:x*y
b = [1,2,3,4]
a = reduce(mul_xy,b)
print(a)

    输出为：24

       sorted（）

排序也是在程序中经常用到的算法。无论使用冒泡排序还是快速排序，排序的核心是比较两个元素的大小。如果是数字，我们可以直接比较，但如果是字符串或者两个dict呢？直接比较数学上的大小是没有意义的，因此，比较的过程必须通过函数抽象出来。

sorted([36, 5, -12, 9, -21], reverse=True)  #reverse将排序颠倒

    输出为：[36, 9, 5, -12, -21]

 

sorted([36, 5, -12, 9, -21], key=abs)  
 # 按绝对值排序key指定的函数将作用于list的每一个元素上，并根据key函数返回的结果进行排序

输出为：[5, 9, -12, -21, 36]

print(sorted(list(map(abs, [36, 5, -12, 9, -21]))))

 

输出为: [5, 9, 12, 21, 36]

 

points = [(5,2), (7,3), (3,4),(1,1),(2,6)]
f_x = lambda x:x[0]  # 按x坐标排序,x[0]表示X坐标的值
print(sorted(points, key=f_x))

f_y = lambda x:x[1]  # 按y坐标排序,x[1]表示Y坐标的值   
print(sorted(points, key=f_y))

f_r = lambda x:x[0]**2+x[1]**2  # 按原点的距离排序
print(sorted(points, key=f_r))

 输出为：

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

 

   装饰器

装饰器的作用就是用一个新函数封装旧函数（是旧函数代码不变的情况下增加功能）然后会返回一个新函数，新函数就叫做装饰器，一般为了简化装饰器会用语法糖@新函数来简化

 # 装饰器方法一：

def x(fun):#  x传了一个新函数
    def y():#  内部函数
        return '你好呀！世界\n翻译为：'+fun()
    return y #  返回y函数功能给x函数

def hello():
    return "hello world!"

hello_2=x(hello)

print(hello_2())

    输出为：

你好呀！世界
翻译为：hello world!

 # 装饰器方法二：使用语法糖@

@x
def hello():
    a = 'hello world!'
    return (a.title())
print(hello())

   输出为：

你好呀！世界
翻译为：hello world!

 

      总结：一个偶然的机会，我接触到了飞桨领航团，加入aistudio官网，在上面学习，也加入了现在所在的AI达人群里，以前的Python经常将我搞得云里雾里，这6周的学习，让我有了很大的进步，也很感谢群里的大佬，很直观的感受，许多和我一样的python小白，会将自己的问题发到群里，答疑的速度非常快，这个是纯看书无法比拟的。也希望以后，我有机会参加更多的这样的达人营，和大家一起学习。