1. 安装Python3（推荐用Anaconda方式安装）。将字符串”Life is short I use Python”转换成数组，然后再将数组拼接成字符串，最后统计出每个字母的出现次数（不区分大小写）。 ```python

    !/usr/bin/env python

    coding=utf-8

def main(): originStr = “Life is short I use Python” list1 = list(originStr)

  1. # 如果 " ".join(list1) 就和原先的字符串一样了
  2. # 这里是为了去掉单词间的空格
  3. newStr = "".join(list1)
  4. lowStr = newStr.lower()
  5. print(count_char_number(lowStr))

def count_char_number(string): dict = {} for i in string:

    # 返回指定键的值，如果值不在字典中返回默认值0
    dict[i] = dict.get(i,0)+1
return dict

程序的入口

if name == “main“: main()


2. 获取操作系统、内核、网卡等信息，以及磁盘、CPU、内存使用情况并写在文本文件里。
```python
#!/usr/bin/env python
# coding=utf-8

import platform
import psutil
import time
import datetime
import codecs

"""
获取系统基本信息
"""

def systems():
    ''' 获取操作系统信息 '''
    sys_str = " 操作系统信息如下：\n"
    sys_str += "    操作系统名称为: " + platform.platform() + "\n"
    sys_str += "    操作系统的版本为: " + platform.version() + "\n"
    return sys_str

def netcards():
    ''' 获取网卡信息 '''
    net_str = []
    info = psutil.net_if_addrs()
    for k,v in info.items():
        for item in v:
            if item[0] == 2 and not item[1]=='127.0.0.1':
                net_str.append((k,item[1]))
    return str(psutil.net_if_addrs())

EXPAND = 1024 * 1024

def mems():
    ''' 获取系统内存使用情况 '''
    mem = psutil.virtual_memory()
    mem_str = " 内存状态如下:\n"
    mem_str += "   系统的内存容量为: " + str(mem.total / EXPAND) + " MB\n"
    mem_str += "   系统的内存已使用容量为: " + str(mem.used / EXPAND) + " MB\n"
    mem_str += "   系统可用的内存容量为: " + str(mem.total / EXPAND - mem.used / (1024 * 1024)) + " MB\n"
    return mem_str


def cpus():
    ''' 获取cpu的相关信息 '''
    cpu_str = " CPU状态如下:\n"
    cpu_status = psutil.cpu_times()
    cpu_str += "   user = " + str(cpu_status.user) + "\n"
    cpu_str += "   system = " + str(cpu_status.system) + "\n"
    cpu_str += "   idle = " + str(cpu_status.idle) + "\n"
    return cpu_str


def disks():
    ''' 查看硬盘基本信息 '''
    disk_str = " 硬盘信息如下:\n"
    disk_status = psutil.disk_partitions()
    for item in disk_status:
        disk_str += str(item) + "\n"
        p = item.device
        disk = psutil.disk_usage(p)
        disk_str += p+"盘容量为: " + str(disk.total / EXPAND) + " MB\n"
        disk_str += p+"盘已使用容量为: " + str(disk.used / EXPAND) + " MB\n"
        disk_str += p+"盘可用的内存容量为: " + str(disk.free / EXPAND) + " MB\n"
    return disk_str

def main():
    handle = codecs.open("system.txt", 'w', encoding='utf-8')
    handle.write(systems())
    handle.write(netcards())
    handle.write(mems())
    handle.write(cpus())
    handle.close()

# 程序的入口
if __name__ == "__main__":
    main()
  1. 使用递归和迭代两种方式实现生成斐波那契数列，t计算出第100个数字并比较差异。（可选：使用yield关键字完成任务） ```python

    !/usr/bin/env python

    coding=utf-8

递归

def Fib_Recursion(n): if n <= 0: return 0 elif n == 1: return 1 else: return Fib_Recursion(n - 1) + Fib_Recursion(n - 2)

def Fib_Loop(n): a, b = 0, 1 while n > 0: a, b = b, a + b n -= 1 return a

计算100个时间太长了

def main(): print(“递归计算:”) print(Fib_Recursion(10)) print(“迭代计算:”) print(Fib_Loop(10))

if name == “main“: main()


4. 判断密码强弱等级程序，要求输入密码，输出密码的等级（建议使用正则表达式和非正则表达式两种写法，并比较性能差异）：
   1. very weak ---- 纯字母 or 数字 or 特殊字符（长度为4~8）
   1. weak ---- 字母+数字 or 特殊字符+数字 or 字母+特殊字符 （字母并非大小写混合，长度为4~8）
   1. medium ---- 大小写字母混合+数字 or 大小写字母混合+特殊字符（长度为4~8）
   1. strong ---- 大小写字母混合+数字+特殊字符（长度为4~8）
   1. very strong ---- 大小写字母混合+数字+特殊字符（长度为8～32）
   1. invalid ---- 匹配不了以上规则的则为无效密码
```python
#!/usr/bin/env python
# coding=utf-8

import sys
from enum import Enum

def getPasswordStrength(password):
    length = len(password)
    if length < 4 or length > 32:
        return Strength.Invalid
    # return Strength.VeryWeak
    if length >= 4 and length <= 8:
        index = getStrengthIndex(password)
        return Strength(index)
    if length > 8:
        index = getStrengthIndex(password)
        if index == 4:
            return Strength(index)
    return Strength.Invalid

# 获取密码强度指数（对应到枚举类的索引）
def getStrengthIndex(password):
    flag = [0, 0, 0, 0]
    symbol = "~!@#$%^&*()_+-*/<>,.[]\\/]"
    for c in password:
        if c.isupper():
            flag[0] = 1
        elif c.islower():
            flag[1] = 1
        elif c.isdigit():
            flag[2] = 1
        elif c in symbol:
            flag[3] = 1
        else:
            # 无效的字符
            return 6
    index = sum(flag)
    # 纯字母的时候有大小写特殊处理
    if index == 2 and flag[0] == 1 and flag[1] == 1:
        index = 1
    return index

def main(argv):
    if (len(argv) < 2):
        print("请输入密码明文!")
        return
    print(getPasswordStrength(argv[1]))

Strength = Enum('Strength', ('VeryWeak', 'Weak', 'Medium', 'Strong', 'VeryStrong', 'Invalid'))

if __name__ == "__main__":
    main(sys.argv)
  1. 使用Python完成以下任务（要求一个脚本文件完成a,b任务，另一个脚本文件完成c,d任务，并将变量参数化）：
    1. 创建文件夹（文件夹名称参数化，运行的时候指定，没指定的时候设置默认名称）
    2. 在此目录下生成文件，文件中有N行的长度为L的随机字符串（建议L小于5，N为10e5）
    3. 选择一个hash函数，将这些字符串散列到10个文件里（hash函数使得相同的字符串在同一个文件里）
    4. 构建大小为10的最小堆，来维护字符串重复次数最多的字符串，依次分析10个文件，获取出现最多的字符串及其次数。 ```python

      !/usr/bin/env python

      coding=utf-8

import os import sys import random import string import codecs

def main(argv): dir = “data” if len(argv) > 1: dir = argv[1] filename = “data” if not os.path.exists(dir): os.makedirs(dir)

i = 0
handle = codecs.open(dir + "/" + filename, 'w', encoding='utf-8')
while i < 10e4: 
    handle.write(genRandomStr(4) + '\n')
    i = i + 1
handle.close()
print("文件写入完成")

def genRandomStr(length): salt = ‘’.join(random.sample(string.ascii_letters + string.digits, length)) return salt

if name == “main“: main(sys.argv)

```python
#!/usr/bin/env python
# coding=utf-8

import sys
import heapq
from collections import Counter

def main(argv):
    dir = "data"
    if len(argv) > 1:
        dir = argv[1]
    print("")

    filename = "data"
    handle = open(dir + "/" + filename, 'r')

    fileHandles = []
    i = 0
    while i < 10:
        fileHandles.append(open(dir + "/" + filename + str(i), 'w'))
        i = i + 1
    line = handle.readline()
    while line:
        i = hash(line) % 10
        fileHandles[i].write(line)
        line = handle.readline()

    i = 0
    while i < 10:
        fileHandles[i].close()
        i = i + 1
    handle.close()
    calcTopN(dir)
    print("计算完成")

# 这里偷懒了一下，没手动构建最小堆，用了现有的库
def calcTopN(dir):
    filename = "data"
    i = 0
    topn = []
    while i < 10:
        handle = open(dir + "/" + filename + str(i), 'r')
        lines = handle.read().splitlines()
        counter = Counter(lines)
        counter.update(counter)
        topn = counter.most_common(10)
        handle.close()
        i = i + 1
    print(topn)

if __name__ == "__main__":
    main(sys.argv)
  1. 学习Python socket编程，创建tcp客户端，获取baidu.com首页内容并保存在本地文件里。 ```python

    !/usr/bin/env python

    coding=utf-8

import socket import codecs

def main():

# 创建socket
socketClient = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
# 连接服务器
socketClient.connect(("www.baidu.com",80))
# 发送请求
socketClient.send(b"GET / HTTP/1.1\r\nHost:www.baidu.com\r\n\r\n")

# 创建一个列表用来储存接收到的数据
listData = []
# 接收数据
while True:
    # 接收到的数据是二进制形式
    content = socketClient.recv(1024)
    if len(content) == 0:
        break # 读完停止
    listData.append(content)
# 将数据转换成字符串
strData = "".join(listData).decode("utf-8")
saveFile("baidu.txt", strData)
print("文件保存完成")

def saveFile(filename, content): handle = codecs.open(filename, ‘w’, encoding=’utf-8’) handle.write(content) handle.close()

if name == “main“: main()

```