7 - 更多字符串和特殊方法

1. 创建字符串

s1 = str()
s2 = str("Welcome") 

s1 = ""
s2 = "Welcome"
s3 = "Welcome"

一个字符串对象是不可变的，一旦创建一个字符串对象出来，那么它的内容就不会再改变、

为了优化性能，Python使用一个对象来表示具有相同内容的字符串。例如，上面的 s2,s3 就指向同一个对象，他们有着相同的 id 。

2.内置字符串处理函数

len 返回字符串中的字符个数
max,min 返回字符串中最大和最小的字符

3.下标运算符[]

Python 下表是从 0 开始的
允许负数下标，它表示相对于字符串末尾的位置

s = "Welcome"
s[-1] = 'e'
s[-2] = 'm'

4 .字符串截取 [start:end]

s = "Welcome"
s[1:4] = "elc"
s[:6] = "Welcom"
s[3:] = "come"
s[2:-1] = "lcom"

4. 连接运算符+、复制运算符*

s1 = "Welcome"
s2 = "Python"
s3 = s1 + "to" + s2   #"Welcome to Python"
s4 = 3 * s1 
s4 = s1 * 3    # "WelcomeWelcomeWelcome"

5. in 和 not in

“come” not in "Welcome"
False

6. 比较字符串

==、!=、>、<、>=、<=

7.迭代字符串

for ch in s:
    print(ch)

8. 测试字符串

• isalnum() 字符是字母或者数字
• isalpha() 字符全部为字母
• isdigit()
• isidentifier() 是Pyhon标识符
• islower()
• isupper()
• isspace()

9.搜索子串

• find(str) 返回第一个str的起始地址
• rfind(str) 返回最后一个str的起始地址
• count(str) 返回str出现的次数
• endswith(str) 判断是否以str结尾
• startwith(str) 判断是否以str结尾

10.删除空格

空格字符：' ', \t, \f, \r, \n

• lstrip() 删除左边空格
• rstrip() 删除右边空格
• strip() 删除两边空格

11.格式化字符串

• center(width) 居中对齐
• ljust(width) 左对齐
• rjust(width) 右对齐
• format()

12.运算符重载和特殊方法

Python 允许为运算符和函数定义特殊的方法来实现常用的操作。Python 使用一种独特的方式来命名 这些方法以辨别它们的关联性。

我们已经知道可以用运算符来对字符串进行操作，如运算符 * 可以结合同一字符串多次，关系运算符（==，！=，>=，<=） 可以用于比较两个字符串。

这些运算符实际上都是在str类中定义的方法。为运算符定义方法被称为运算符的重载。
当定义这些方法时，名字前后加两个下划线以便Python辨别它们的关联性。
运算符之间的映射关系：

• +： __add__
• *：__mul__
• -：__sub__
• /：__truediv__
• %：__mod__
• <：__lt__
• <=：__le__
• ==：__eq__
• !=：__ne__
• >：__gt__
• >=：__ge__
• [index]：__getitem__
• in：__contains__
• len：__len__
• str：__str__

也就是说在使用s1 + s2的时候，其实等价于s1.__add__(s2)
那么你也可以为自己的类写这样的方法，时间运算符的重载。

举例：

class Rational:
    def __init__(self, numerator = 0, denominator = 1):
        divisor = gcd(numerator, denominator)       
        self.__numerator = (1 if denominator > 0 else -1) \
            * int(numerator / divisor)
        self.__denominator = int(abs(denominator) / divisor)

    # Add a rational number to this rational number
    def __add__(self, secondRational):
        n = self.__numerator * secondRational[1] + \
            self.__denominator * secondRational[0]
        d = self.__denominator * secondRational[1]
        return Rational(n, d)

    # Subtract a rational number from this rational number
    def __sub__(self, secondRational):
        n = self.__numerator * secondRational[1] - \
            self.__denominator * secondRational[0]
        d = self.__denominator * secondRational[1]
        return Rational(n, d)

    # Multiply a rational number to this rational 
    def __mul__(self, secondRational):
        n = self.__numerator * secondRational[0]
        d = self.__denominator * secondRational[1]
        return Rational(n, d)

    # Divide a rational number by this rational number
    def __truediv__(self, secondRational):
        n = self.__numerator * secondRational[1]
        d = self.__denominator * secondRational[0]
        return Rational(n, d)

    # Return a float for the rational number
    def __float__(self):
        return self.__numerator / self.__denominator 

    # Return an integer for the rational number
    def __int__(self):
        return int(self.__float__())

    # Return a string representation  
    def __str__(self):
        if self.__denominator == 1:
            return str(self.__numerator)
        else:
            return str(self.__numerator) + "/" + str(self.__denominator)

    def __lt__(self, secondRational): 
        return self.__cmp__(secondRational) < 0

    def __le__(self, secondRational): 
        return self.__cmp__(secondRational) <= 0

    def __gt__(self, secondRational): 
        return self.__cmp__(secondRational) > 0

    def __ge__(self, secondRational): 
        return self.__cmp__(secondRational) >= 0

    # Compare two numbers
    def __cmp__(self, secondRational): 
        temp = self.__sub__(secondRational)
        if temp[0] > 0:
            return 1
        elif temp[0] < 0:
            return -1
        else:
            return 0        

    # Return numerator and denominator using an index operator
    def __getitem__(self, index): 
        if index == 0:
            return self.__numerator
        else:
            return self.__denominator

def gcd(n, d):
    n1 = abs(n);
    n2 = abs(d)
    gcd = 1

    k = 1
    while k <= n1 and k <= n2:
        if n1 % k == 0 and n2 % k == 0:
            gcd = k
        k += 1

    return gcd