Python学习记录2-函数与字符串

函数

• 函数是代码的一种组织形式
• 函数应该能完成一项特定的工作，而且一般一个函数只完成一项工作
• 有些语言，分函数和过程两个概念，通俗解释是，有返回结果的叫函数，无返回结果的叫过程，python不加以区分
• 函数的使用
  • 函数的使用需要先定义
  • 使用函数，俗称调用

    # 定义一个函数
    # 只是定义的话不会执行
    # 1. def关键字，后跟一个空格
    # 2. 函数名，自己定义，起名需要遵循命名规则，约定俗成，大驼峰命名只给类用
    # 3. 后面括号和冒号不能省，括号内可以有参数
    # 4. 函数内所有代码缩进

    >>> def func():
    >>> print("我是一个函数")
    
    >>> print("我不是函数内部的东西")  #这一句没有在函数内部的缩进 是跟函数声明同级的
                                    #所以不属于函数内部
                                
    输出：我不是函数内部的东西
    
    ---------------------------------------------------------------------------------------------------
    
    # 函数的调用
    # 直接写出函数的名字，后面小括号不能省略，括号内内容根据情况
    >>> def func():
               print("我是一个函数")
    
    >>> func()
    
    输出：我是一个函数

函数的参数和返回值

• 参数：负责给函数传递一些必要的数据或者信息
  • 形参 （形式参数）:在函数定义的时候用到的参数，没有具体值，只是一个占位符号
  • 实参 （实际参数）: 在调用函数的时候输入的值
• 返回值：调用函数的时候返回的执行结果
  • 使用return返回结果
  • 并不强制要求返回值，如果没有返回值，推荐使用return None标示函数结束
  • 函数一旦执行return，则函数立即结束
  • 如果函数没有return关键字，则默认返回None

    # 形参和实参
    # 参数person只是一个符号
    # 调用的时候用另一个
    >>> def hello(person):
            print("{0},你好吗？".format(person))
            print("{},你好吗？".format(person))

    >>> p = "小明"
    # 调用函数，需要把p作为实参传入
    >>> hello(p)
        
    输出：    
    小明,你好吗？
    小明,你好吗？
    
    ---------------------------------------------------------------------------------------------------
    >>> def hello(person):
            print("{0},你好吗？".format(person))
            print("{},你好吗？".format(person))
    >>> pp = hello("赵四")
    >>> print(pp)  #hello函数没有返回值 默认返回None
    
    输出：
    赵四,你好吗？
    赵四,你好吗？
    None
    
    ---------------------------------------------------------------------------------------------------
    
    # help负责随时为你提供帮助
    >>> help(print)
    
    Help on built-in function print in module builtins:

    print(...)
        print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)

        Prints the values to a stream, or to sys.stdout by default.
        Optional keyword arguments:
        file:  a file-like object (stream); defaults to the current sys.stdout.
        sep:   string inserted between values, default a space.
        end:   string appended after the last value, default a newline.
        flush: whether to forcibly flush the stream.     
    

九九乘法表

    # 九九乘法表
    # version1.0
    >>> for i in range(1,10): #控制外循环，从 1 到 9  因为range是左包括右不包括 包括1 但不包括10 所以到9
            for j in range(1,i+1): #内循环，每次从第一个数字开始，打印到跟行数相同的数量
                print(i*j,end="  ") #修改print的end为空格 可以让输出的内容之间有些间距 比较美观
            print() #此处是为了换行   print()函数的内置end是换行\n 什么不输出也会换行

    输出：
    1  
    2  4  
    3  6  9  
    4  8  12  16  
    5  10  15  20  25  
    6  12  18  24  30  36  
    7  14  21  28  35  42  49  
    8  16  24  32  40  48  56  64  
    9  18  27  36  45  54  63  72  81

    ---------------------------------------------------------------------------------------------------
    
    # 尝试用函数打印九九乘法表
    # version2.0
    def jiujiu():
        for i in range(1,10): #控制外循环，从 1 到 9
            for j in range(1,i+1): #内循环，每次从第一个数字开始，打印到跟行数相同的数量
                print(i*j,end="  ")
            print()
        return None   # 如果没有返回值默认返回None  写不写没关系 一般可以写上  

    jiujiu() #结果与上面相同
    
    ---------------------------------------------------------------------------------------------------
    
    # 改造上面函数
    # version3.0
    def printLine(line_num):
        '''
        line_num: 代表行号

        打印一行九九乘法表
        '''
        for i in range(1,line_num+1):
            print(line_num * i , end="  ") #end与等号之间不能有空格 这个跟 != 一样

        print() #换行

    def jiujiu():
        for o in range(1,10):
            printLine(o) #调用输出一行的函数 并传入参数
        return None    

    jiujiu() #结果与上面相同

参数详解

• 参数分类
  • 普通参数/位置参数
  • 默认参数
  • 关键字参数
  • 收集参数

    # 普通参数
    >>> def normal_param(one, two):
            print(one + two)
            return None

    >>> normal_param(1,2)
    
    输出：3
    
    ---------------------------------------------------------------------------------------------------
    
    # 默认参数

    >>> def default_param(one, two, three=100):
            print(one + two + three)
            return None

    >>> default_param(1,2) #虽然此处给了两个参数，但是第三个参数是默认参数，默认值是100
    
    输出：103
    
    ---------------------------------------------------------------------------------------------------
    
    # 关键字参数
    # 如果说忘记了参数的顺序 可以在形参中直接赋值

    >>> def keys_param(one, two, three=2):
            print(one + two + three)
            return None


    >>> keys_param(two=2,one=1,three=3) #如果参数有默认值 重新赋值时会覆盖掉默认值
    
    输出：6
    

str字符串

• str
• 转义字符
• 格式化
• 内建函数

字符串

• 表示文字信息
• 用单引号、双引号、三引号括起来

    #单引号里面不能再用单引号 所以加个 \转义 这点差不多都
    >>> a = 'I\'m a chinese'
    #双引号里是可以加单引号的 单引号里也可以加双引号
    >>> b = "I'm a chinese"
    >>> c ="""
        1
        2
        3
        4

        """
    #三引号原样输出
    >>> print(a)
    >>> print(b)
    >>> print(c)
    
    输出：
    I'm a chinese
    I'm a chinese
    1
    2
    3
    4

转义字符

• 用一个特色的方法表示出一系列不方便写出的内容，比如回车键，换行符，退格符
• 借助反斜杆字符，一旦字符串中出现反斜杠，则反斜杠后面一个或者几个字符表示已经不是原来的意思了，进行了转义
• 在字符串中，一旦出现反斜杠就要加倍小心，可能由转义字符出现
• 不同操作系统对换行操作有不同的表示
  • windows：\n
  • Linux：\r\n

    # 转义字符
    # Let's Go
    # 使用转义字符
    >>> s = 'Les\'s Go！'
    >>> print(s)
  
    # 使用单引号嵌套
    >>> a = "Let's Go！"
    >>> print(a)
  
    # 表示斜杠
    # 比如表示C:\User\test
    >>> b = "c:\\User\\test"
    >>> print(b)
  
    # 回车换行
    >>> d = "Ich\r\nliebe\r\nChina"
    >>> print(d)
  
    # 水平制表符
    >>> e = "I \tLove \tChina"
    >>> print(e)
  
    输出：
    Les's Go！
    Let's Go！
    c:\User\test
    Ich
    liebe
    China
    I   Love    China
  
    ---------------------------------------------------------------------------------------------------
  
    # 单个斜杆的用法
    # 在python里，单个斜杠表示此行未结束，出于美观，需要下一行继续
  
    >>> f = "啦啦啦啦啦啦 \
        哈哈哈哈哈 \
        嘻嘻嘻嘻嘻嘻 \
        "
    >>> print(f)
  
    #函数中也可以用 单个斜杠 换行
    >>> def myDemo(x,\
                  y,\
                  z):
    >>> print("哈哈哈哈哈")
    >>> myDemo(1,2,3)    
  
    输出：
    啦啦啦啦啦啦 哈哈哈哈哈 嘻嘻嘻嘻嘻嘻 
    哈哈哈哈哈

格式化

• 把字符串按照一定格式进行打印或者填充
• 格式化的分类：
  • 传统格式化
  • format

    # 填充
    >>> g = "I love China"
    >>> print(g)
    
    输出：
    I love China

字符串的传统格式化方法

• 使用%进行格式化
• %（百分号）也叫占位符

    # %s 表示简单的字符串
    # 占位符可以单独使用
    >>> h = "I love %s"
    >>> print(h % "China")

    >>> print(h%"中国")
    
    输出：
    I love China
    I love 中国
    
    ---------------------------------------------------------------------------------------------------
    
    >>> print("I love %s" % "China") #%s占位符 要被替换
    #占位符一般只能被同类型替换，或者替换类型能被转换成占位符的类型
    >>> print("I love %s" % 100)
    
    输出：
    I love China
    I love 100
    
    ---------------------------------------------------------------------------------------------------
    
    >>> i = "我今年 %d 岁了"
    >>> print(i % 20)#此处的%d 代表整数 如果换成字符串 比如'20' 会报类型错误:需要一个数字却得到一个字符串
            
    输出：
    我今年 20 岁了
    
    >>> p = 2/3
    >>> print("%.2f" % p)
    
    输出：
    0.67
    ---------------------------------------------------------------------------------------------------
    
    # 如果占位符要两个 可以用括号括起来要传递给占位符的参数
    #实际需要进行格式化的信息的数量必须与百分号后面给出的数据数量匹配，否则爆错
    # %f格式化后默认格式后面带了很多0 不是很美观
    >>> j = "I'm %.2fKG weight,%.2fm Height"
    >>> print(j%(65,1.75))

    # %.2f 表示保留几位小数 一般用于%f中
    
    输出：
    I'm 65.00KG weight,1.75m Height
    

format格式化

• 使用函数形式进行格式化，代替以前的百分号

    # 不用指定位置，按顺序读取
    # 方式1
    >>> k = "{} {}!"
    >>> print(k.format("Hello", "World"))

    # 方式2
    >>> L= "{} {}!".format("Hello", "World")
    >>> print(L) #相当于打印的是"Hello World"

    # 设置指定位置 从0开始按顺序替换
    >>> m = "{0} {1}".format("hello","world")
    >>> print(m)

    # 设置指定位置
    >>> n = "I love {0} and {0} love me".format("hhh")
    >>> print(n)

    # 使用命名参数
    >>> o = "我叫{name},我是{sex}"
    >>> o = o.format(name="哈哈哈",sex="男")
    >>> print(o)

    输出：
    Hello World!
    Hello World!
    hello world
    I love hhh and hhh love me
    我叫哈哈哈,我是男
    
    ---------------------------------------------------------------------------------------------------
    
    # 通过字典设置参数，需要解包
    # 使用命名参数
    >>> o = "我叫{name},我是{sex}"

    >>> o = o.format(name="哈哈哈",sex="男")

    >>> print(o)

    >>> o_dict = {"name":"哈哈哈","sex":"男"}

    >>> p = o.format(**o_dict) #前面加两个*代表解包  这个后面在解释...

    >>> print(p)
    
    输出：
    我叫哈哈哈,我是男
    我叫哈哈哈,我是男
    
    ---------------------------------------------------------------------------------------------------
    
    # 对数字的格式化需要用到
    >>> r = "I am {:.2f}m height,{:.2f} KG weight"
    >>> print(r.format(1.75,65))
    
    输出：
    I am is 1.75m height,65.00 KG weight
    
    ---------------------------------------------------------------------------------------------------
    
    # ^,<,>分别是居中、左对齐、右对齐，后面带宽度，
    # ：号后面填充的字符，只能是一个字符，不指定则默认是用空格填充。
    # + 表示在正数前显示 +，负数前显示 -;
    # b：二进制、d：十进制、o：八进制、x：十六进制。
    # 此外我们可以使用大括号 {} 来转义大括号，

    #大括号转义 大括号用大括号转义
    >>> p = "format函数是使用{{}}来进行占位的"
    >>> print(p.format("{}"))
    
    输出：
    format函数是使用{}来进行占位的

str内置函数

• 字符串查找类，find，index，islower
• find：查找字符串中是否包含一个子串
• index：跟find的唯一区别是index如果找不到会引发ValueError异常
• find，rfind：从左开始查找或者从右开始查找

    >>> s ="I'm a chinese"
    >>> s1 = "chinese"
    # 返回第一次发现这个字符串的位置
    >>> s.find(s1)

    # 找不到返回-1
    >>> s.find("haha")

    # index与find的区别：find找不到会返回int类型 -1  index会抛出ValueError错误
    # s.index("hhh")

    >>> s = "a b c d e f g"
    >>> s1 = "f"

    >>> s.find(s1,1,11)
    # 可以发现下标是从0开始的

    >>> s.rfind(s1)

    输出：
    10
    

判断类函数

• 此类函数的特点一般都是用is开头，比如islower
• isalpha：判断是否是字母，需要注意两点
  • 此函数默认的前提是字符串至少包含一个字符，如果没有，同样返回False。
  • 汉字被认为是alpha，所以，此函数不能作为区分英语字母还是汉字的标识，区分中英文请使用unicode码。
  • 注意使用区别，防止被坑
• isdigit，isnumeric，isdecimal三个判断数字的函数

  • 此类函数不建议使用，在后期爬虫中，判断是否是数字建议采用正则表达式的方式

    对这三个函数的一个总结：
    digit:
    True: Unicode数字，byte数字（单字节），全角数字（双字节），罗马数字
    False：汉字数字
    Error：无

    isdecimal()
    True：Unicode数字，全角数字（双字节）
    False：罗马数字，汉字数字
    Error：byte数字（单字节）
          
    isnumeric()
    True：Unicode数字，全角数字（双字节），罗马数字，汉字数字
    False：无
    Error：byte数字（单字节）

    # 以下三个都不是的，因为有除了字母以外的空格等
    >>> s1 = "我们对着灯，玩手机"
    >>> s2 = "bengberba is friend of baberbeng"
    >>> s3 = "I'm the 1.st！"

    >>> print(s1.isalpha())
    >>> print(s2.isalpha())
    >>> print(s3.isalpha())
    
    输出：
    False
    False
    False
    
    ---------------------------------------------------------------------------------------------------
    
    # 需要注意的是，因为输入法的问题，输入罗马数字可能得不到我们想要的结果
    >>> chin_num = "一二三四"
    >>> print(chin_num.isdigit())
    >>> print(chin_num.isnumeric())
    >>> print(chin_num.isdecimal())
    >>> print(chin_num.islower())
    
    输出：
    False
    True
    False
    False

内容判断类

• startswith/endswith：是否以xxx开头或结尾
  • 检测某个字符串是否以某个子字符串开头，常用三个参数
  • suffix :被检查的字符串，必须有
  • start: 检查范围的开始范围
  • end: 检查范围的结束范围
• islower/isupper：判断字符串是否是大写或者小写

    >>> name = "Yan Haotian"
    >>> words = "Yan Haotian is a chinese people,so he loves his motherland very much"
    >>> endWord = 'much'
    >>> print(words.startswith(name))
    >>> print(words.endswith(endWord))

    输出：
    True
    True
    
    ---------------------------------------------------------------------------------------------------
    
    >>> s1 = "I love China"
    >>> s2 = "IloveChina"
    >>> s3 = "ilovechina"
    >>> s4 = "i love china"
    >>> s5 = "我爱中国"

    >>> print(s1.islower())
    >>> print(s2.islower())
    >>> print(s3.islower())
    >>> print(s4.islower())
    # 汉字字符串无大小写概念，所以不适用
    >>> print(s5.islower())
    >>> print(s5.isupper())

    输出：
    False
    False
    True
    True
    False
    False
    

总结

python中的函数跟java相比也是格式上有些差别，其他差不多，并且可以看得出python中确实提供了很多的内置函数，方便开发。