python学习-函数模块，数据结构，字符串和列表（上）

for i in range(100, 1000):
    a = i//100
    b = i//10 % 10
    c = i % 10
    if i == a**3+b**3+c**3:
       print(i)

num  = int(input('请输入正整数'))
## 123456
rever_num = 0
while num >0:
    rever_num = rever_num*10 + num%10
    num //= 10
print(rever_num)

for i in range(0,21):
    for j in range(0,34):
        z = 100 -5*i -3*j
        if 5*i + 3*j + z//3 ==100 and z % 3 ==0:
            print(f'公鸡{i}只，母鸡{j}只，小鸡{z}只')

公鸡2只，母鸡30只，小鸡0只
公鸡5只，母鸡25只，小鸡0只
公鸡8只，母鸡20只，小鸡0只
公鸡11只，母鸡15只，小鸡0只
公鸡14只，母鸡10只，小鸡0只
公鸡17只，母鸡5只，小鸡0只
公鸡20只，母鸡0只，小鸡0只

a, b = 1, 1
# 通过递推公式算出后面的18个数
for _ in range(18):
    a, b = b, a + b
    print(b, end=' ')

m = int(input('m = '))
n = int(input('n = '))
# 计算m的阶乘
fm = 1
for num in range(1, m + 1):
    fm *= num
# 计算n的阶乘
fn = 1
for num in range(1, n + 1):
    fn *= num
# 计算m-n的阶乘
fm_n = 1
for num in range(1, m - n + 1):
    fm_n *= num
# 计算C(M,N)的值
print(fm//fn//fm_n)

def fac(num):
    fn = 1
    for i in range(1,num+1):
        fn*=i
    return fn

m = int(input('m = '))
n = int(input('n = '))
print(fac(m)//fac(n)//fac(m-n))

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

# 用星号表达式来表示args可以接收0个或任意多个参数
def add(*args):
    total = 0
    # 可变参数可以放在for循环中取出每个参数的值
    for val in args:
        total += val
    return total

print(add(1,2,3,4,5,6,7))

module1.py

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

module2.py

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

test.py

import module1
import module2

# 用“模块名.函数名”的方式（完全限定名）调用函数，
module1.foo()    # hello, world!
module2.foo()    # goodbye, world!

test.py

import module1 as m1
import module2 as m2

m1.foo()    # hello, world!
m2.foo()    # goodbye, world!

from module1 import foo
foo()    # hello, world!
from module2 import foo
foo()    # goodbye, world!

from module1 import foo as f1
from module2 import foo as f2

f1()    # hello, world!
f2()    # goodbye, world!

函数是功能相对独立且会重复使用的代码的封装

s1 = 'hello, world!'
s2 = "你好，世界！"
print(s1, s2)
# 以三个双引号或单引号开头的字符串可以折行
s3 = '''
hello, 
world!
'''
print(s3, end='')

提示：print函数中的end=''表示输出后不换行，即将默认的结束符\n（换行符）更换为''（空字符）。

# 头尾带单引号的hello, world!
s1 = '\'hello, world!\''
print(s1)
# 头尾带反斜杠的hello, world!
s2 = '\\hello, world!\\'
print(s2)

在字符串'hello\n'中，\n表示换行；而在r'hello\n'中，\n不再表示换行，就是反斜杠和字符n。

# 字符串s1中\t是制表符，\n是换行符
s1 = '\time up \now'
print(s1)
# 字符串s2中没有转义字符，每个字符都是原始含义
s2 = r'\time up \now'
print(s2)

s1 = 'hello' + ' ' + 'world'
print(s1)    # hello world
s2 = '!' * 3
print(s2)    # !!!
s1 += s2     # s1 = s1 + s2
print(s1)    # hello world!!!
s1 *= 2      # s1 = s1 * 2
print(s1)    # hello world!!!hello world!!!

s1 = 'a whole new world'
s2 = 'hello world'
print(s1 == s2, s1 < s2)      # False True
print(s2 == 'hello world')    # True
print(s2 == 'Hello world')    # False
print(s2 != 'Hello world')    # True
s3 = '骆昊'
print(ord('骆'), ord('昊'))               # 39558 26122
s4 = '王大锤'
print(ord('王'), ord('大'), ord('锤'))    # 29579 22823 38180
print(s3 > s4, s3 <= s4)      # True False

s1 = 'hello world'
s2 = 'hello world'
s3 = s2
# 比较字符串的内容
print(s1 == s2, s2 == s3)    # True True
# 比较字符串的内存地址
print(s1 is s2, s2 is s3)    # False True

s1 = 'hello, world'
print('wo' in s1)    # True
s2 = 'goodbye'
print(s2 in s1)      # False

s1 = 'hello, world'
print(len(s1))                  # 12
print(len('goodbye, world'))    # 14

如果希望从字符串中取出某个字符，我们可以对字符串进行索引运算，运算符是[n]，其中n是一个整数，假设字符串的长度为N，那么n可以是从0到N-1的整数，其中0是字符串中第一个字符的索引，而N-1是字符串中最后一个字符的索引，通常称之为正向索引；在Python中，字符串的索引也可以是从-1到-N的整数，其中-1是最后一个字符的索引，而-N则是第一个字符的索引，通常称之为负向索引。注意，因为字符串是不可变类型，所以不能通过索引运算修改字符串中的字符。
s1 = 'abc123456'
N = len(s1)

# 获取第一个字符
print(s1[0], s1[-N])    # a a

# 获取最后一个字符
print(s1[N-1], s1[-1])  # 6 6

# 获取索引为2或-7的字符
print(s1[2], s1[-7])    # c c

# 获取索引为5和-4的字符
print(s1[5], s1[-4])    # 3 3

s1 = 'abc123456'

# i=2, j=5, k=1的正向切片操作
print(s1[2:5])       # c12

# i=-7, j=-4, k=1的正向切片操作
print(s1[-7:-4])     # c12

# i=2, j=9, k=1的正向切片操作
print(s1[2:])        # c123456

# i=-7, j=9, k=1的正向切片操作
print(s1[-7:])       # c123456

# i=2, j=9, k=2的正向切片操作
print(s1[2::2])      # c246

# i=-7, j=9, k=2的正向切片操作
print(s1[-7::2])     # c246

# i=0, j=9, k=2的正向切片操作
print(s1[::2])       # ac246

# i=1, j=-1, k=2的正向切片操作
print(s1[1:-1:2])    # b135

# i=7, j=1, k=-1的负向切片操作
print(s1[7:1:-1])    # 54321c

# i=-2, j=-8, k=-1的负向切片操作
print(s1[-2:-8:-1])  # 54321c

# i=7, j=-10, k=-1的负向切片操作
print(s1[7::-1])     # 54321cba

# i=-1, j=1, k=-1的负向切片操作
print(s1[:1:-1])     # 654321c

# i=0, j=9, k=1的正向切片
print(s1[:])         # abc123456

# i=0, j=9, k=2的正向切片
print(s1[::2])       # ac246

# i=-1, j=-10, k=-1的负向切片
print(s1[::-1])      # 654321cba

# i=-1, j=-10, k=-2的负向切片
print(s1[::-2])      # 642ca