2018-03-10

字符串

1. 常见使用

def main():
    str1 = 'hello, world!'
    # 通过len函数计算字符串的长度
    print(len(str1))  # 13
    # 获得字符串首字母大写的拷贝
    print(str1.capitalize())  # Hello, world!
    # 获得字符串变大写后的拷贝
    print(str1.upper())  # HELLO, WORLD!
    # 从字符串中查找子串所在位置
    print(str1.find('or'))  # 8
    print(str1.find('shit'))  # -1
    # 与find类似但找不到子串时会引发异常
    # print(str1.index('or'))
    # print(str1.index('shit'))
    # 检查字符串是否以指定的字符串开头
    print(str1.startswith('He'))  # False
    print(str1.startswith('hel'))  # True
    # 检查字符串是否以指定的字符串结尾
    print(str1.endswith('!'))  # True
    # 将字符串以指定的宽度居中并在两侧填充指定的字符
    print(str1.center(50, '*'))
    # 将字符串以指定的宽度靠右放置左侧填充指定的字符
    print(str1.rjust(50, ' '))
    str2 = 'abc123456'
    # 从字符串中取出指定位置的字符(下标运算)
    print(str2[2])  # c
    # 字符串切片(从指定的开始索引到指定的结束索引)
    print(str2[2:5])  # c12
    print(str2[2:])  # c123456
    print(str2[2::2])  # c246
    print(str2[::2])  # ac246
    print(str2[::-1])  # 654321cba
    print(str2[-3:-1])  # 45
    # 检查字符串是否由数字构成
    print(str2.isdigit())  # False
    # 检查字符串是否以字母构成
    print(str2.isalpha())  # False
    # 检查字符串是否以数字和字母构成
    print(str2.isalnum())  # True
    str3 = '  jackfrued@126.com '
    print(str3)
    # 获得字符串修剪左右两侧空格的拷贝
    print(str3.strip())


if __name__ == '__main__':
    main()

函数

1.定义函数关键字def ，命名规则和变量名的规则一样
2.定义函数的参数相当于数学里面的函数的自变量，函数的结果通过 return返回出来
3.独立的功能模块将来可以重复使用这些模块

 # 求 x1 + x2 + x3 + x4 = 8的解得个数
 # 思路：相当于把8个苹果分给四个人每人至少一个 M = 7, N =3
def  f(x):
    y =1
    for z in range(1, x + 1):
        y *= z
    return y
m = int(input('m = '))
n = int(input('n = ')
print(f(m) // f(n) // f(m - n))
    
# 普通方法
"""

输入M和N计算C(M,N)

"""

m = int(input('m = '))
n = int(input('n = '))
fm = 1
for num in range(1, m + 1):
    fm *= num
fn = 1
for num in range(1, n + 1):
    fn *= num
fmn = 1
for num in range(1, m - n + 1):
    fmn *= num
print(fm // fn // fmn)

4.函数的不定参数

def add(*args):
    """
    在参数前使用*表示args时可变的参数
    也就是说调用add函数时可以传入0个或者多个参数
    :param args:
    :return:
    """
    total = 0
    for val in args:
        total += val
    return total
print(add())
print(add(1))
print(add(1, 2))
print(add(1, 3, 5))

5.传递函数的参数可以不按顺序排列,也可以在定义函数的时候就使用默认参数

def add(a=0, b=0,c=0):
    return a + b + c
print(add(c=5, a=1,b=2))
print(add())

6.定义相同的函数名后者的结果会覆盖掉前者，解决此方法通过模块（module）,通过导入不同的模块也就是文件的名字，通过import来导入，

def foo():
    print('hello')
def foo():
    print('good')
foo()
# 打印结果为good

方法module1.py

def foo():
    print('hello, world!'

module2.py

def foo():
    print('goodbye, world!')

test.py

from module1 import foo

foo()   # 输出hello, world!

from module2 import foo

foo()   # 输出goodbye, world!

也可以这样

import module1 as m1
import module2 as m2

m1.foo()
m2.foo()

不能写成这样

from module2 import foo
from module1 import foo

foo()   # 输出hello, world!

7.当需要导入模块到另外的一个模块中使用时，我们只想使用该模块的功能而不像让该模块的一些程序实现，可以用下面的方法
test1.py

def foo():
    pass


def bar():
    pass


# __name__是Python中一个隐含的变量它代表了模块的名字
# 只有被Python解释器直接执行的模块的名字才是__main__
if __name__ == '__main__':
    print('call foo()')
    foo()
    print('call bar()')
    bar()

test2.py

import test1.py

# 导入test1.py时 不会执行模块中if条件成立时的代码 因为模块的名字是test1.py而不是__main__

8.作用域

• 作用域按照局部--嵌套--全局--内置的顺序来调用，如果想在不改变其设定的值得前提下可以使用global和nonlocal等关键字来改变使用的变量

def foo():
    global a
    a = 200
    print(a)  # 200


if __name__ == '__main__':
    a = 100
    foo()
    print(a)  # 200

列表

1.简单的使用

def main():
    fruits = ['grape', 'apple', 'strawberry', 'waxberry']
    fruits += ['pitaya', 'pear', 'mango']
    # 循环遍历列表元素
    for fruit in fruits:
        print(fruit.title(), end=' ')
    print()
    # 列表切片
    fruits2 = fruits[1:4]
    print(fruits2)
    # fruit3 = fruits  # 没有复制列表只创建了新的引用
    # 可以通过完整切片操作来复制列表
    fruits3 = fruits[:]
    print(fruits3)
    fruits4 = fruits[-3:-1]
    print(fruits4)
    # 可以通过反向切片操作来获得倒转后的列表的拷贝
    fruits5 = fruits[::-1]
    print(fruits5)

  
   
   
    list1 = ['orange', 'apple', 'zoo', 'internationalization', 'blueberry']
    list2 = sorted(list1)
    # sorted函数返回列表排序后的拷贝不会修改传入的列表
    # 函数的设计就应该像sorted函数一样尽可能不产生副作用
    list3 = sorted(list1, reverse=True)
    # 通过key关键字参数指定根据字符串长度进行排序而不是默认的字母表顺序
    list4 = sorted(list1, key=len)
    print(list1)
    print(list2)
    print(list3)
    print(list4)
    # 给列表对象发出排序消息直接在列表对象上进行排序
    list1.sort(reverse=True)
    print(list1)

if __name__ == '__main__':
    main()

2.生成表达式和生成器

import sys


def main():
    f = [x for x in range(1, 10)]
    print(f)
    f = [x + y for x in 'ABCDE' for y in '1234567']
    print(f)
    # 用列表的生成表达式语法创建列表容器
    # 用这种语法创建列表之后元素已经准备就绪所以需要耗费较多的内存空间
    f = [x ** 2 for x in range(1, 1000)]
    print(sys.getsizeof(f))  # 查看对象占用内存的字节数
    print(f)
    # 请注意下面的代码创建的不是一个列表而是一个生成器对象
    # 通过生成器可以获取到数据但它不占用额外的空间存储数据
    # 每次需要数据的时候就通过内部的运算得到数据(需要花费额外的时间)
    f = (x ** 2 for x in range(1, 1000))
    print(sys.getsizeof(f))  # 相比生成式生成器不占用存储数据的空间
    print(f)
    for val in f:
        print(val)


if __name__ == '__main__':
    main()

3. yield关键字生成 菲波那切数列的生成器

def fib(n):
    a, b = 0, 1
    for _ in range(n):
        a, b = b, a + b
        yield a


def main():
    for val in fib(20):
        print(val)

元组

1.不能修改元组里面的元素，创建时间明显少于创建列表的时间
2.元组的简单的使用方法

def main():
    # 定义元组
    t = ('呵呵', 38, True, '四川成都')
    print(t)
    # 获取元组中的元素
    print(t[0])
    print(t[3])
    # 遍历元组中的值
    for member in t:
        print(member)
    # 重新给元组赋值
    # t[0] = '王大锤'  # TypeError
    # 变量t重新引用了新的元组原来的元组将被垃圾回收
    t = ('王大锤', 20, True, '云南昆明')
    print(t)
    # 将元组转换成列表
    person = list(t)
    print(person)
    # 列表是可以修改它的元素的
    person[0] = '李小龙'
    person[1] = 25
    print(person)
    # 将列表转换成元组
    fruits_list = ['apple', 'banana', 'orange']
    fruits_tuple = tuple(fruits_list)
    print(fruits_tuple)
    

if __name__ == '__main__':
    main()

集合

1.集合之间的运算和数学上的使用集合时的一些定义一样

    set1 = {1, 2, 3, 3, 3, 2}
    print(set1)
    print('Length =', len(set1))
    set2 = set(range(1, 10))
    print(set2)
    set1.add(4)
    set1.add(5)
    set2.update([11, 12])
    print(set1)
    print(set2)
    set2.discard(5)
    # remove的元素如果不存在会引发KeyError
    if 4 in set2:
        set2.remove(4)
    print(set2)
    # 遍历集合容器
    for elem in set2:
        print(elem ** 2, end=' ')
    print()
    # 将元组转换成集合
    set3 = set((1, 2, 3, 3, 2, 1))
    print(set3.pop())
    print(set3)
    # 集合的交集、并集、差集、对称差运算
    print(set1 & set2)
    # print(set1.intersection(set2))
    print(set1 | set2)
    # print(set1.union(set2))
    print(set1 - set2)
    # print(set1.difference(set2))
    print(set1 ^ set2)
    # print(set1.symmetric_difference(set2))
    # 判断子集和超集
    print(set2 <= set1)
    # print(set2.issubset(set1))
    print(set3 <= set1)
    # print(set3.issubset(set1))
    print(set1 >= set2)
    # print(set1.issuperset(set2))
    print(set1 >= set3)
    # print(set1.issuperset(set3))

字典

1.由键值对组成

def main():
    scores = {'呵呵': 95, '白元芳': 78, '狄仁杰': 82}
    # 通过键可以获取字典中对应的值
    print(scores['呵呵'])
    print(scores['狄仁杰'])
    # 对字典进行遍历(遍历的其实是键再通过键取对应的值)
    for elem in scores:
        print('%s\t--->\t%d' % (elem, scores[elem]))
    # 更新字典中的元素
    scores['白元芳'] = 65
    scores['诸葛王朗'] = 71
    scores.update(冷面=67, 方启鹤=85)
    print(scores)
    if '武则天' in scores:
        print(scores['武则天'])
    print(scores.get('武则天'))
    # get方法也是通过键获取对应的值但是可以设置默认值
    print(scores.get('武则天', 60))
    # 删除字典中的元素
    print(scores.popitem())
    print(scores.popitem())
    print(scores.pop('呵呵', 100))
    # 清空字典
    scores.clear()
    print(scores)


if __name__ == '__main__':
    main()

面向对象

1.class定义类,定义类首先要找出类的静态属性和动态的行为属性，构造方法，从类里可以创建出对象，然后通过方法给对象发消息产生产生某种答复。

class Rectangle(object):
    """
    矩形类
    """

    def __init__(self, width, height):
        """
        构造器

        :param width: 宽度
        :param height: 高度
        """
        self._width = width
        self._height = height

    def area(self):
        """
        计算周长

        :return: 矩形的周长
        """
        return self._height * self._width

    def perimeter(self):
        """
        计算面积

        :return: 矩形的面积
        """
        return (self._height + self._width) * 2