课上练习

习题1. 任意给定一个集合，按照包含元素数量从小到大，列出该集合的所有真子集

"""
结题思路，以包含3个元素的集合{"a", "b", "c"}为例
一个集合中的元素数量为N，那么其包含子集的数量为2^N
包含0个元素
            □ □ □          000   包含0个1
包含1个元素
            □   □   "c"     001   包含1个1
            □   "b"  □      010
            "a"  □   □      100
包含2个元素
            □   "b"  "c"     011   包含2个1
            "a"  "b"  □      110
            "a"  □   "c"     101
包含3个元素
            "a"  "b"  "c"     111  包含3个1
"""

SpecialSet = {"a", "b", "c", "d", "e"}
N = len(SpecialSet)
SpecialList = list(SpecialSet)

# 按照集合包含元素数量遍历
for ElementNum in range(N+1):
    print("含有", ElementNum, "个元素的子集")
    for Index in range(2**N):

        IndexBinStr = str(bin(Index))  # 将Index转换为二进制数字
        IndexBinStr = IndexBinStr.replace("0b", "")   # 去掉二进制数前面的0b
        IndexBinStr = str("0")*(N - len(IndexBinStr)) + IndexBinStr   # 前面补0 ， 形成一个N位的二进制
        """
        求解其中1的个数，判断是否与子集元素个数相等
        """
        if len(IndexBinStr.replace("0", "")) == ElementNum:
            # 根据IndexBunStr的位置判断入选元素
            subset = {SpecialList[Index] for Index in range(0, len(SpecialList)) if IndexBinStr[Index] == '1'}

            print(subset)

习题2. 求出1~10000中所有由且仅由3,6,9三个数字构成的数之和。
说明：
693、3396、963都是由且仅由3、6、9三个数字构成，符合要求；
1235、968不是全由3、6、9三个数字构成，不符合要求；
669不包含数字3，不符合要求。

Sum = 0
SpecialSet = {'3', '6', '9'}
for num in range(0, 10001):
	Set = set(str(num))
	if Set == SpecialSet:
		Sum += num
	else:
		continue
print(Sum)


Out:
243972

习题3. 求出1~10000中所有由3或6或9三个数字构成的数之和。
说明：
3、33、396、96、999都是由3或6或9三个数字构成的数。

Sum = 0
Set1 = {"3", "6", "9"}
for num in range(1, 10001):
    Set = set(str(num))

    if Set <= Set1:
                    Sum += num
    else:
        continue
print(Sum)

Out:
558540

习题4. 求出1~10000中所有不包含3或6或9三个数字构成的数之和。
说明：
17、25、587不包含3或6或9三个数字构成的数，符合要求；
17、25、587不包含3或6或9三个数字构成的数，不符合要求。

Sum = 0
Set1 = {"3", "6", "9"}
for num in range(1, 10001):
    Set = set(str(num))

    if Set & Set1 == set():
                    Sum += num
    else:
        continue
print(Sum)

Out:
10298971

习题5. 对于给定的整数列表，例如[12,32,43,12,33,90,100,32]，生成一个字典，字典中包含两项：一项是由列表中大于40的元素组成的列表，另一项是由列表中小于40的元素组成的列表，保持原列表中元素的先后顺序不变。

"""
注意等于40的情况
"""
List = [12, 32, 43, 12, 33, 90, 100, 32]
NewList1 = []
NewList2 = []
for ii in List:
    if ii<40:
        NewList1.append(ii)
    elif ii>40:
        NewList2.append(ii)
    else:
        continue
Dict1 = {"More": NewList1}
Dict2 = {"Less": NewList2}
print(Dict1)
print(Dict2)

Out:
{'More': [12, 32, 12, 33, 32]}
{'Less': [43, 90, 100]}

习题6. 任意给定一个字符串：
1）判断该字符串是否为纯英文字符构成；
2）判断该字符串是否为纯小写英文字符构成；
3）判断该字符串是否为纯大写英文字符构成；
4）判断该字符串中包含多少个不同英文字母（大小写不同）；
5）判断该字符串中包含多少个不同小写英文字母；
6）判断该字符串中包含多少个不同大写英文字母；
说明：
“abcbcDEDE66”
不是纯英文字母构成、不是纯小写英文字母构成、不是纯大写英文字母构成
包含5个字母：a,b,c,D,E
包含3个小写字母：a,b,c
包含2个大写字母：D,E

String = "abcbcDEDE66"
StringSet = set(String)

# 小写字母的ASCII码97(a)~122(z)
LetterSetLowerSet = {chr(ASCIINumber) for ASCIINumber in range(97, 122+1)}
"""
chr() 用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符。
chr(48).chr(49),chr(97)对应0 1 a
"""
# 大写字母的ASCII码65（A)~90(Z)
LetterSetCapital = {chr(ASCIINumber) for ASCIINumber in range(65, 90+1)}
# 大小写字母集合 并集
LetterSet = LetterSetLowerSet | LetterSetCapital

# 判断该字符串是否为纯英文字母构成
if StringSet <= LetterSet:
    print("给出的字符是全部都由字母组成")
else:
    print("给出的字符不是都由纯字母组成")

# 判断该字符串是否全部由小写字母组成
if StringSet <= LetterSetLowerSet:
    print("给出的字符串是由纯小写字母组成")
else:
    print("给出的字符串不是由纯小写字母组成")

# 判断该字符串是否全部由大写字母组成
if StringSet <= LetterSetCapital:
    print("给出的字符串是由纯大写字母组成")
else:
    print("给出的字符串不是由纯大写字母组成")

# 给出该字符串包含多少个不同小写字母
print("给出的字符串中小写字母的数量",\
      len(StringSet & LetterSetLowerSet))

# 给出该字符串包含多少个不同大写字母
print("给出的字符串中大写字母的数量",\
      len(StringSet & LetterSetCapital))

Out:

给出的字符不是都由纯字母组成
给出的字符串不是由纯小写字母组成
给出的字符串不是由纯大写字母组成
给出的字符串中小写字母的数量 3
给出的字符串中大写字母的数量 2

习题7. 求出1~10000所有回文数的和。
说明：
所谓回文数指的是2332,121,33,555,6666,这种从左读和从右读完全一样的数。

Sum = 0
for i in range(1, 10000):
    CharI = str(i)
    if CharI == CharI[::-1]:
        Sum += i
print(Sum)

Out
545040

习题8. 生成一个列表X，X中的元素由1~1000中所有包含数字3或3的倍数组成，即[3,6,9,12,13……]，并且删除列表中索引为0,5,10,15,20,25,……的元素。

# 方法一
x = [i for i in range(1, 1000) if ('3' in str(i)) or (i % 3 == 0)]
print(x)

# 方法二
x = [i for i in range(1, 1000) if ('3' in str(i)) or (i % 3 == 0)]   
for Index in range(len(x), 0-1, -1):  # 注意：删除元素后，元素的索引发生变化
    if 0 == Index % 5:
        x.pop(Index)
print(x)

习题9. 求出所有水仙数的和。水仙数是指一个三位数，其各位数立方和等于该数。

Sum = 0
for i in range(100, 1000):
    StrI = str(i)
    if int(StrI[0]) ** 3 + int(StrI[1]) ** 3 + int(StrI[2]) ** 3 == i:
        Sum += i
print(Sum)

Out:
1301

习题10. 有1,2,3,4个数字，能组成多少个互不相同且无重复数字的三位数，都是多少？

Num = 0
for x in range(1, 5):
    for y in range(1, 5):
        for z in range(1, 5):
            if (x != y) and (y != z) and (x != z):
                Num += 1
                print("{0}{1}{2}" .format(x, y, z))
print("Num=", Num)

习题11. 判断101-200之间有多少个素数，并输出所有素数。

for i in range(101, 201):
    for j in range(2, i):
        if (0 == i % j):
            break
    else:
            print(i)

习题12. 一个数如果恰好等于它的因子之和，这个数就称为"完数"。例如6=1＋2＋3.编程找出1000以内的所有完数

for i in range(1, 1000):
    sum = 0
    for j in range(1, i):
        if 0 == i % j:
            sum += j
    if i == sum:
        print(i)

习题13. 求编写函数解以下所有数之和，其中n为拥护指定的函数的输入参数
1
1、2
1、2、3
1、2、3、4
……
1、2、3、4、……、5

def getSum():
    ListNum = []
    n = int(input("Please enter the number: "))
    Sum = 0

    for i in range(1, n + 1):
        for j in range(i - 1, 0, -1):
            Sum2 = i + j
            ListNum.append(Sum2)
            Sum += Sum2
    return Sum

Out：

print(getSum())
Please enter the number: 5
60

习题14. 对于给定字典列表，请按照得分score从大到小的顺序，重新排列该列表，并挑选出score为63的字典
StudentList = [{“name”: “Tom”, “age”: 22, “score”: 63},
{“name”: “Jerry”, “age”: 45, “score”: 32},
{“name”: “Lucy”, “age”: 21, “score”: 85},
{“name”: “Tony”, “age”: 51, “score”: 65},
{“name”: “Bool”, “age”: 12, “score”: 97}]

StudentList = [{"name": "Tom", "age": 22, "score": 63},
               {"name": "Jerry", "age": 45, "score": 32},
               {"name": "Lucy", "age": 21, "score": 85},
               {"name": "Tony", "age": 51, "score": 65},
               {"name": "Bool", "age": 12, "score": 97}]

# 方法一 定义函数
def takeSecond(elem):
    return elem["score"]


StudentList.sort(key=takeSecond, reverse=False)
print(StudentList)

# 方法二 匿名函数
StudentList.sort(key=lambda x: x["score"], reverse=False)
print(StudentList)

Out：

[{'age': 45, 'name': 'Jerry', 'score': 32}, {'age': 22, 'name': 'Tom', 'score': 63}, {'age': 51, 'name': 'Tony', 'score': 65}, {'age': 21, 'name': 'Lucy', 'score': 85}, {'age': 12, 'name': 'Bool', 'score': 97}]
[{'age': 22, 'name': 'Tom', 'score': 63}]

习题15.对于给定的正整数，判断其是否为质数

def isPrime(n):
    for i in range(2, n//2):
        if n % i == 0:
            PrimeNum = False
            break
        else:
            PrimeNum = True
    return PrimeNum

习题16. 给定一个字符串和一个整数size，请把大小为size的左半区整体移到右半区，右半区整体移到左边。
例如：
字符串为“abcdefg”,size = 3
结果为“defgabc”

String = "abcdefg"
Size = 3
StringNew = String[int(Size):int(len(String))]+String[0:Size]
print(StringNew)

习题17. 给定一个字符串，其中只含有字母字符和*字符现在想把“*”全部挪到字符串的左边，字母字符移到右边
说明
“offer” 结果 “****offer”

String = "o*f*f*e*r"
print("*"*String.count("*") + String.replace("*","")

习题18. 给定一个整数（存储长度为32bit），求出该整数补码形式中包含1的数量

"""
计算机中，数值以二进制的补码形式保存
正数的原码=反码=补码
负数的补码=原码取反+1
计算中显示的数值和实际存储的数值不同
"""
NumDec = -36
Num = (str(bin(NumDec & 0xFFFFFFFF)).replace("0b", "")).count("1")
print(Num)

Out：

29

解析：
bin(NumDec & 0xFFFFFFFF)
>>> '0b11111111111111111111111111011100'
与上0xFFFFFFFF是为了让其显示在计算机中真正存储的数

习题19. 给定一个正整数n，对于1≤x≤n的所有正整数x，打印出所有满足以下要求的所有正整数：
x对应的二进制形式中，在0的左边知道包含一个1。
例如 n = 2
十进制 二进制 是否满足
1 1 不满足
2 10 满足
3 11 不满足
4 100 满足
5 101 满足
6 110 满足

n = 36
for i in range(1, n + 1):
    iBinStr = str(bin(i))
    if "10" in iBinStr.replace("0b", ""):
        print(i)
    else:
        continue

习题20. 编写一个函数，输入为正整数n,该函数求出不超过n的所有奇数之和

def oddSum(n):
    if n <= 0:
        return
    else:
        return sum([i for i in range(1, n + 1) if i % 2 == 1])

习题21. 对于一个由正整数构成的列表，列表中的元素均为3位数，将列表中的元素按照十位数的大小，从小到大顺序重新排列
例如 NumberList = [812, 312, 812, 999, 231, 721, 900, 800]的排序结果为[800,900,312,812,812,721,231,999]

def getSecond(n):
    nStrSecond = str(n)[1]
    return nStrSecond


NumberList = [812, 312, 812, 999, 231, 721, 900, 800]
NumberList.sort(reverse=False)  # 先将大小简单排序
NumberList.sort(key=getSecond, reverse=False)
print(NumberList)

习题22. 对于一个给定字符串构成的列表，字符串均为纯英文字幕组成（包含大小写）将该字符串按照首字母顺序排序（字母升序），
1）对于首字母相同的字符串，按照包含字母数量由少到多排列
2）对于首字母相同的字符串，按照包含字母数量由多到少排列
如果首字母相同，包含字母顺序也相同，则按照一般字母顺序比较。
NameList = [“Jom”, “Tom”, “Jack”, “Tony”, “Chery”, “Lucy”, “jim”, “Lily”, “jomy”]

NameList = ["Jom", "Tom", "Jack", "Tony", "Chery", "Lucy", "jim", "Lily", "jomy"]
NameList.sort()  # 先按首字母排序 ['Chery', 'Jack', 'Jom', 'Lily', 'Lucy', 'Tom', 'Tony', 'jim', 'jomy']


def paixv1(str):
    con1 = ord(str[0]) * 1000000  # 确保距离每一个字母之间距离拉开
    con2 = len(str)
    return con1 + con2


def paixv2(str):
    con1 = ord(str[0]) * 1000000
    con2 = 10000 - len(str)  # 避免从某一个ASCII值后往前数
    return con1 + con2


NameList1 = sorted(NameList, key=paixv1, reverse=False)
NameList2 = sorted(NameList, key=paixv2, reverse=False)

print(NameList1)
print(NameList2)