1. python的缺点

   • 执行效率稍低，因此计算密集型任务可以由C/C++编写。
   • 在开发时可以选择的框架太多（如Web框架就有100多个），有选择的地方就有错误。

2. python解释器

   • 官方的Python解释器是用C语言实现的，也是使用最为广泛的Python解释器，通常称之为CPython。除此之外，Python解释器还有Java语言实现的Jython、C#语言实现的IronPython以及PyPy、Brython、Pyston等版本

3. 计算机硬件系统由五大部分构成：

   • 运算器

   • 控制器

     运算器和控制器放在一起就是我们通常所说的中央处理器，它的功能是执行各种运算和控制指令以及处理计算机软件中的数据。

   • 存储器

   • 输入设备

   • 输出设备

     2.格式化输出

     print函数中输出的字符串使用了占位符语法，其中%d是整数的占位符，%f是小数的占位符，%%表示百分号（因为百分号代表了占位符，所以带占位符的字符串中要表示百分号必须写成%%），字符串之后的%后面跟的变量值会替换掉占位符然后输出到终端中。

4. 三角形面积计算（海伦公式）

   p = (a + b + c) / 2

   area = (p * (p - a) * (p - b) * (p - c)) ** 0.5

5. for-in循环

   如果明确的知道循环执行的次数或者要对一个容器进行迭代（后面会讲到），那么使用for-in循环

6. while循环

   如果要构造不知道具体循环次数的循环结构，那么用while循环。while循环通过一个能够产生或转换出bool值的表达式来控制循环，表达式的值为True循环继续，表达式的值为False循环结束。

7. 最大公约数与最小公倍数

   x = int(input('x = '))
   y = int(input('y = '))
   if x > y:
   x, y = y, x
   for factor in range(x, 0, -1):
   if x % factor == 0 and y % factor == 0:
   print('%d和%d的最大公约数是%d' % (x, y, factor))
   print('%d和%d的最小公倍数是%d' % (x, y, x * y // factor)) #最小公倍数与最大公约数的关系
   break

8. 简单图形的打印

   row = 6

   for i in range(row):
   for j in range(i+1):
   print("",end="") #这个print()起的仅仅起换行的作用 print() for i in range(row): for j in range(row-i-1): print(" ",end="") for k in range(i+1): print("",end="")
   print()
   for i in range(row):
   for j in range(row-i-1):
   print(" ",end="")
   for k in range(1+2i): print("",end="")
   print()

   *
   **

   ---

   ---

   ---

   ---

    *
   **

   ---

   ---

   ---

   ---

    *
   ***

   ---

   ---

   ---

   ---

   [Finished in 0.5s]

1.百鸡百鸣问题

"""
公鸡5元一只，母鸡3元一只，小鸡1元三只，
用100块钱买一百只鸡，问公鸡、母鸡、小鸡
各有多少只？
"""
for x in range(1,21):
    for y in range(1,33):
        z = 100-x-y
        if 100 == 5*x+3*y+(1/3)*z:
            print("公鸡有%d只；母鸡有%d只；小鸡有%d只"%(x,y,z))


#这是暴力法求解，很多时候挺有用，但是有时候不行，这个1/3就是个很大的不定因素
print(1/3)

公鸡有4只；母鸡有18只；小鸡有78只
公鸡有8只；母鸡有11只；小鸡有81只
公鸡有12只；母鸡有4只；小鸡有84只
0.3333333333333333
[Finished in 0.1s]

1. 斐波那契数列

   def fib(n):
   if n==1:
   return 1
   if n==2:
   return 2
   else:
   return fib(n-1)+fib(n-2)

   for i in range(1,21): #生成前20个数
   print(fib(i),end=" ")

   1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 [Finished in 0.1s]

3.求完美数

"""
完美数又称为完全数或完备数，它的所有的真因子
（即除了自身以外的因子）的和（即因子函数）恰
好等于它本身。例如：6（$6=1+2+3$）和28（$28
=1+2+4+7+14$）就是完美数。
"""
for num in range(1,10001):
    ls = []
    sum = 0
    for i in range(1,num):
        if num%i==0:
            ls.append(i)
    if ls!= []:
        for i in ls:     #列表求和的稳妥方式
            sum += i
    if sum==num:
        print(num)


6
28
496
8128
[Finished in 4.2s]    #太慢了

1. 用模块管理函数

   • 对于任何一种编程语言来说，给变量、函数这样的标识符起名字都是一个让人头疼的问题，因为我们会遇到命名冲突这种尴尬的情况。最简单的场景就是在同一个.py文件中定义了两个同名函数，由于Python没有函数重载的概念，那么后面的定义会覆盖之前的定义。
   • 当然上面的这种情况我们很容易就能避免，但是如果项目是由多人协作进行团队开发的时候，团队中可能有多个程序员都定义了名为foo的函数，那么怎么解决这种命名冲突呢？答案其实很简单，Python中每个文件就代表了一个模块（module），我们在不同的模块中可以有同名的函数，在使用函数的时候我们通过import关键字导入指定的模块就可以区分到底要使用的是哪个模块中的foo函数

   #范例
   import module1 as m1
   import module2 as m2

   m1.foo()
   m2.foo()

   • 但【如果引入的模块里面有除了函数以外的其它的代码，那么Python解释器在导入这个模块时就会执行这些代码】

   import 完美数 as m1 #虽然它实际上是个文件，但是并不是引入完美数.py
   import 百鸡百鸣 as m2
   print()
   print(m1.foo())
   print(m2.foo())

   6
   28
   496
   8128
   公鸡有4只；母鸡有18只；小鸡有78只
   公鸡有8只；母鸡有11只；小鸡有81只
   公鸡有12只；母鸡有4只；小鸡有84只
   0.3333333333333333

   这是m1里的foo函数
   None
   这是m2里的foo函数
   None
   [Finished in 4.2s]

   • 事实上我们可能并不希望如此，因此如果我们在模块中编写了执行代码，最好是将这些执行代码放入如下所示的条件中，这样的话除非直接运行该模块，if条件下的这些代码是不会执行的，因为只有直接执行的模块的名字才是"main"。

   #完美数.py
   def foo():
   print("这是m1里的foo函数")

   name是Python中一个隐含的变量它代表了模块的名字

   【只有被Python解释器直接执行的模块的名字才是main】

   if name == 'main':
   for num in range(1,10001):
   ls = []
   sum = 0
   for i in range(1,num):
   if num%i==0:
   ls.append(i)
   if ls:
   for i in ls:
   sum += i
   if sum==num:
   print(num)

   import 完美数 as m1 #虽然它实际上是个文件，但是并不是引入完美数.py
   import 百鸡百鸣 as m2
   print()
   print(m1.foo())
   print(m2.foo())

   这是m1里的foo函数
   None
   这是m2里的foo函数
   None
   [Finished in 0.1s]

   • 但是如果将代码写成了下面的样子，那么程序中调用的是最后导入的那个foo，因为后导入的foo覆盖了之前导入的foo。

   from module1 import foo
   from module2 import foo

   输出goodbye, world!

   foo()

2. 回文数的判断

def is_palindrome(num):
    """判断一个数是不是回文数"""
    temp = num
    total = 0
    while temp>0:       #这个循环实际上实现了数字的反转
        total = total*10 + temp%10
        temp //=10
    return total == num


-    尝试用字符串方法判断回文数


#错误方法
def is_palindrome(number):
    """判断一个数是不是回文数"""
    num = list(str(number))
    for i in range(len(num)):
        temp = num[0]                        #弄了半天只改变了首尾两个元素有个锤子用？
        num[0] = num[-1]                     #将列表翻转最好是用单向列表
                                             #另外，如果这一步的num是石头人类型时，会报错'str' object does not support item assignment；
                                              这是因为字符串是不可变数据,仅仅可以被索引
        num[-1] = temp
    return num == number


def is_palindrome(number):
    """判断一个数是不是回文数"""
    num = list(str(number))
    temp = []                                #temp是一个替换列表；
    for i in range(len(num)):
        result.append(num.pop())

    return str(number) == "".join(temp)      #将列表转化成字符串的方法
                                             #将字符串转化成列表： list.split(" ")
                                             #讲真join方法看起来是很奇怪的
    return list(str(number)) == result       #另一种判断方法

1. 转义

   • 不希望字符串中的\表示转义，我们可以通过在字符串的最前面加上字母r来加以说明

   s1 = r'\'hello, world!\''
   s2 = '\'hello, world!\''
   print(s1)
   print(s2)

   \'hello, world!\'
   'hello, world!'
   [Finished in 0.1s]

2. 字符串的运算符

   • 索引
   • 切片（切记不能改变）

   str1 = 'hello, world!'

   获得字符串首字母大写的拷贝

   print(str1.capitalize()) # Hello, world!

   获得字符串每个单词首字母大写的拷贝

   print(str1.title()) # Hello, World!

   获得字符串变大写后的拷贝

   print(str1.upper()) # HELLO, WORLD!

   从字符串中查找子串所在位置

   print(str1.find('or')) # 8 #这个觉得有用在爬虫中
   print(str1.find('shit')) # -1

   将字符串以指定的宽度居中并在两侧填充指定的字符

   print(str1.center(50, '*'))

   将字符串以指定的宽度靠右放置左侧填充指定的字符

   print(str1.rjust(50, ' '))

   与find类似但找不到子串时会引发异常

   print(str1.index('or'))

   print(str1.index('shit'))

   检查字符串是否以指定的字符串开头

   print(str1.startswith('He')) # False
   print(str1.startswith('hel')) # True

   检查字符串是否以指定的字符串结尾

   print(str1.endswith('!')) # True
   str2 = 'abc123456'

   检查字符串是否由数字构成

   print(str2.isdigit()) # False

   检查字符串是否以字母构成

   print(str2.isalpha()) # False

   检查字符串是否以数字和字母构成

   print(str2.isalnum()) # True
   str3 = ' jackfrued@126.com '
   print(str3)

   获得字符串修剪左右两侧空格之后的拷贝

   print(str3.strip())

3. 列表

   添加元素

   list1.append(200)
   list1.insert(1, 400)

   清空列表元素

   list1.clear()

   if 3 in list1:
   list1.remove(3)

   • 列表的排序

   l1 = [1,2,30]
   l2 = ["abc","de","f"]
   print(l1)
   sorted(l1,reverse=True)
   print(l1)
   l1.sort(reverse=True)
   print(l1)

   print(l2)
   l2.sort(key=len) #按照元素有短到长的顺序进行排序
   print(l2) #但是不能排数字：TypeError: object of type 'int' has no len()

   [1, 2, 30]
   [1, 2, 30] # sorted函数返回列表排序后的拷贝不会修改传入的列表
   # 函数的设计就应该像sorted函数一样尽可能不产生副作用
   [30, 2, 1] #list.sort()函数就会使传入的列表发生变化
   ['abc', 'de', 'f']
   ['f', 'de', 'abc']
   [Finished in 0.5s]

4. 元组

   • 元组中的元素是无法修改的，事实上我们在项目中尤其是多线程环境（后面会讲到）中可能更喜欢使用的是那些不变对象（一方面因为对象状态不能修改，所以可以避免由此引起的不必要的程序错误，简单的说就是一个不变的对象要比可变的对象更加容易维护；另一方面因为没有任何一个线程能够修改不变对象的内部状态，一个不变对象自动就是线程安全的，这样就可以省掉处理同步化的开销。一个不变对象可以方便的被共享访问）。所以结论就是：如果不需要对元素进行添加、删除、修改的时候，可以考虑使用元组，当然如果一个方法要返回多个值，使用元组也是不错的选择。

5.集合

- 集合的创建

# 创建集合的字面量语法
set1 = {1, 2, 3, 3, 3, 2}
print(set1)                                        #{1, 2, 3}，这是集合的特性
print('Length =', len(set1))
# 创建集合的构造器语法(面向对象部分会进行详细讲解)
set2 = set(range(1, 10))
set3 = set((1, 2, 3, 3, 2, 1))
print(set2, set3)


{1, 2, 3}
Length = 3
{1, 2, 3, 4, 5, 6, 7, 8, 9} {1, 2, 3}
{3, 5, 6, 9, 10, 12, 15, 18, 20, 21, 24, 25, 27, 30, 33, 35, 36, 39, 40, 42, 45, 48, 50, 51, 54, 55, 57, 60, 63, 65, 66, 69, 70, 72, 75, 78, 80, 81, 84, 85, 87, 90, 93, 95, 96, 99}
[Finished in 0.1s]


-    向集合添加和删除元素


set1 = {1, 2, 3, 3, 3, 2}
print(set1)
set1.update([10,11])
print(set1)
#set1.update(13)            #TypeError: 'int' object is not iterable
#set1.discard(11,10)            #TypeError: discard() takes exactly one argument (2 given)
set1.discard(11)
print(set1)
#set1.discard([10,11])        #TypeError: unhashable type: 'list'
set1.remove(10)
print(set1)


{1, 2, 3}
{1, 2, 3, 10, 11}
{1, 2, 3, 10}
{1, 2, 3}
[Finished in 0.2s]


-    集合的交集、并集、差集、对称差运算


set1 = {1, 2, 3, 3, 3, 2}
set2 = set(range(1, 10))
set3 = set((1, 2, 3, 3, 2, 1))
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. 字典

   创建字典的构造器语法

   items1 = dict(one=1,two=2)
   print(items1)

   {'one': 1, 'two': 2}

   通过zip函数将两个【【序列】】压成字典

   items2 = dict(zip(['a', 'b', 'c'], '123'))
   print(items2)

   {'a': '1', 'b': '2', 'c': '3'}

   #字典的遍历
   for key,item in items1.items():
   print("key:{} value:{}".format(key,item))

   for value in items1.values():
   print("value:{}".format(value))

   key:one value:1
   key:two value:2
   value:1
   value:2

   更新字典中的元素

   items1["one"] = "one"
   print(items1)
   items1.update(one=1,two=2)
   print(items1)

   {'one': 'one', 'two': 2}
   {'one': 1, 'two': 2}

   删除字典中的元素

   print(items1.popitem())
   print(items1)

   ('two', 2) #popitem返回的是一个元组
   {'one': 1}

   清空字典

   items1.clear()

2. 跑马灯

   import os
   import time

   def main():
   content = '北京欢迎你为你开天辟地…………'
   while True:
   # 清理屏幕上的输出
   os.system('cls') # os.system('clear')
   print(content)
   # 休眠200毫秒
   time.sleep(0.2)
   content = content[1:] + content[0] #模拟跑马灯

   if name == 'main':
   main()

3. 生成验证码

   import random

   def generate_code(code_len=4):
   """
   生成指定长度的验证码
   :param code_len: 验证码的长度(默认4个字符)
   :return: 由大小写英文字母和数字构成的随机验证码
   """
   all_chars = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
   code = ""
   for i in range(4):
   index = random.randint(0,len(all_chars)-1) #randint()需要两个限；否则TypeError: randint() missing 1 required positional argument: 'b'
   #randint生成的随机数的范围是 [下限，上限]（左闭右闭区间）
   code += all_chars[index]
   return code

   print(generate_code())

4. 获取文件名的后缀名

   def get_suffix(filename, has_dot=False):
   """
   获取文件名的后缀名
   :param filename: 文件名
   :param has_dot: 返回的后缀名是否需要带点
   :return: 文件的后缀名
   """
   pos = filename.find(".")
   if 0<pos<len(filename)-1:
   if has_dot==True:
   index = pos
   else:
   index = pos+1
   return filename[index:]
   else:
   return ""

   print(get_suffix("字典.py"))