第一模块: 开发基础(2)

二进制

二进制与十进制之间的转换
求342的二进制数

bin(342)
'0b101010110'

---

ASCII码

计算通过ASCII码将数字转换成文字

每一个0或1所占的空间单位为bit(比特)
计算机最小的存储单位为1bytes=8bit,1bytes缩写为1B
1KB = 1024B

---

字符编码发展历史

• GB2312 1981年
• GBK1.0 1995年
• GB18030 2000年
• Unicode 1991年
• UTF-8

Python2默认编码是ascii码,需要指定编码为utf-8才能支持中文# -*- conding: utf-8 -*-;
Python3默认编码编码是;

---

Python数据类型补充

浮点数

浮点数是属于有理数的子集,在计算机中用以近似标识任意某个实数.

科学计数法1332 = 1.332e3
复数-5+4j(量子力学)

python默认浮点数是17位的精度

高精度浮点数方法

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[InvalidOperation, DivisionByZero, Overflow])
>>> getcontext().prec
28
>>> getcontext().prec = 50
>>> a = Decimal(1)/Decimal(3)
>>> a
Decimal('0.33333333333333333333333333333333333333333333333333')

列表

列表是一个数据的集合,集合被可以放任何数据类型,可以对集合进行方便的增删改查;

列表的功能:

• 创建

name = [1, 2, 3]
name = list('123')

• 查询,通过index查询,从0开始 name[2]
• 切片 name[1:3] name[:2] name[::2] name[1:-2]
• 增加 name.append(1) name.insert(0,3)
• 修改 name[1] = 2
• 删除 name.pop() name.remove(2) del name[2]
• 循环

for i in name:
  print(i)

for i in range(10):
  print(i)

• 排序 name.sort()
• 扩展 list1.extend(list2) list1 + list2

使用枚举打印列表和索引值:

>>> name = ['alex', 'zhangsan', 'lisi']
	    
>>> enumerate(name)
	    
<enumerate object at 0x00000214D33EECA8>
>>> for i in enumerate(name):
	    print(i)

	    
(0, 'alex')
(1, 'zhangsan')
(2, 'lisi')

深拷贝

name = ['alex', 'zhangsan', 'lisi', [1, 3]]
import copy
n1 =  copy.deepcopy(name)

字符串

字符串是一个有序的字符的集合, 用于存储和标识基本的文本信息, 一对单,双或三引号中间包含的内容称之为字符串.

特性:

• 有序
• 不可变

字符串方法(*号为常用方法):

capitalize
casefold
center *
count *
encode
endswith
expandtabs
find
format *
format_map
index
isalnum
isalpha
isdecimal
isdigit *
isidentifier
islower
isnumeric
isprintable
isspace
istitle
isupper
join *
ljust
lower
lstrip
maketrans
partition
replace *
rfind
rindex
rjust
rpartition
rsplit
rstrip
split *
splitlines
startswith
strip *
swapcase
title
translate
upper
zfill

元祖

元祖其实就是只读列表,支持切片,

name = ('zhangsan', 'lisi')
name.index('lisi')
name.count('zhangsan')

hash

hash, 一般翻译成"散列",就是把任意长度的输入,通过散列算法,变换成固定长度的输出,该输出就是散列值. 这种转换是一种压缩映射,也就是,散列值的空间远小于输入空间,不同的输入可能会散列成相同的输出,所以不可能从散列值来唯一的确定输入值.简单的说是一种将任意长度的消息压缩到某个固定长度的消息摘要的函数.

特征:
hash值的计算过程是依据这个值的一些特征计算的,这就要求hash值必须固定,因此hash的值必须是不可变的.

用途:

• 文件签名
• md5 加密
• 密码验证

字典

字典是一种key-value的数据类型,使用就像我们上学用的字典,通过笔画,字母来查对应页的详细内容.

特性:

• key-value结构
• key必须可hash, 且必须为不可变数据类型,必须唯一
• 可存放任意多个值, 可修改, 可以不唯一
• 无序
• 查找速度快

字典的创建与特性

• 创建

person = {"name": "fbo", 'age': 18}
person = dict(name='seven', age = 20)
person = dict({"name": "egon", 'age': 20})
person = dict(["name", "haha"], ['age', 18])
{}.fromkeys(['k1', 'k2'],[])

字典的常见操作

1. dic.keys()
2. dic.values()
3. dic.items()
4. dic.iteritems() dic.iterkeys() dic.itervalues()
5. dic['new_key'] = 'new_value'
6. dic.setdefault(key, None)
7. dic.pop(key[, default])
8. dic.clear()
9. dic.['key'] = 'new_value'
10. dic.update(dic2)
11. dic['key']
12. dict.get(key, default = None)
13. for k in dic.keys()
14. for k,v in dic.items()
15. for k in dic
16. len(dic)

练习:
写代码, 有如下字典,按照要求实现每一个功能die = {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}

1. 请循环遍历出所有的key

for k in  die.keys():
  print(k)

2. 请循环遍历出所有的value

for v in die.values():
  print(v)

3. 请循环遍历出书友的key和value

for k,v in die.items():
  print(k,v)

4. 请在字典中添加一个键值对'k4': 'v4',输出添加后的字典

die['k4'] = 'v4'
print(die)

5. 请删除字典中的键值对'k1', 'v1',并输出删除后的字典

die.pop('k1')
print(die)

6. 请删除字典中的键'k5'对应的键值对, 如果字典中不存在'k5',则不报错, 并让其返回None

die.pop('k5', None)

7. 请获取字典中'k2'的值
   die.get('k2')
8. 请获取字典中'k6'的值,如果'k6'不存在,则不报错,让其返回None
   die.get('k6')
9. 现有 dic2 = {'k1': 'v111', 'a': 'b'}通过一行操作使dic2 =

>>> dic2 = {'k1': 'v111', 'a': 'b'}
>>> dic2['k1'] = 'v1'
>>> dic2['k2'] = 'v2'
>>> dic2['k3'] = 'v3'
>>> dic2
{'k2': 'v2', 'k1': 'v1', 'a': 'b', 'k3': 'v3'}

10. 组合嵌套题, 写代码, 有如下列表,按照要求实现每一个功能

"""
lis = [['k', ['qwe', 20, {'k1': ['tt', 3, '1']},89], 'ab']]
- 将lis中的tt变成大写(两种方式)
- 将列表中的3变成字符串'100'
- 将列表中的字符串'1'变成数字101
"""

lis[0][1][2].get('k1')[0] = 'TT'
lis[0][1][2].get('k1')[1] = '100'
lis[0][1][2].get('k1')[0] = 101

lis[0][1][2]['k1'][0] = 'TT'
lis[0][1][2]['k1'][0] = '100'
lis[0][1][2]['k1'][0] = 101

11. 按照要求实现一下功能:
    现有一个列表 li = [1,2,3,'a','b',4,'c'],有一个字典(此字典是动态生成的,你不知道他里面有多少键值对,所以用dic = {}模拟字典); 现在要完成这样的操作: 如果该字典你没有'k1'这个键, 那就创建这个'k1'键和其对应的值(该对应的值设置为空列表), 并将li中的索引位位奇数对应的元素,添加到'k1'这个键对应的空列表中,如果字典中有'k1'这个键,且k1对应的value是列表类型,那么将li中的索引位为奇数的元素,添加到'k1'这个键对应的列表中

#!/usr/bin/env python3                                                                                                                                                         
#Author:fbo
#Time:2018-03-23 21:21:11
#Name:test.py
#Version:V1.0

li = [1,2,3,'a','b',4,'c']
#dic = {}
dic = {'k1': ['start']}

if not dic.get('k1', None):
    dic['k1'] = []
    for i in range(len(li)):
        if i % 2:
            dic['k1'].append(li[i])
else:
    if type(dic['k1']) == type([]):
        for i in range(len(li)):
            dic['k1'].append(li[i])

print(dic)

集合类型

集合是一个无序, 不从夫的数据组合,它的主要作用如下:

• 去重
• 关系测试, 交集、差集、并集等关系

>>> l = [1,2,3,4,5]
>>> s = set(l)
>>> s
{1, 2, 3, 4, 5}
>>> s = {1,2,3,4,5}

交集:

set1.intersection(set2)
set1 & set2

差集

set1.difference(set2)
set1 - set2

并集

set1.union(set2)
set1 | set2

对称差集

set.symmetric_difference(set2)

子集和超集

set1.issubset(set2)
set2.issupperset(set2)

---

字符编码回顾

www.cnblogs.com/alex3714/articles/7550940.html

---

练习

1. 请用代码实现：利用下划线将列表的每一个元素拼接成字符串，li＝['alex', 'eric', 'rain']
   '_'.join(li)
2. 查找列表中元素，移除每个元素的空格，并查找以a或A开头并且以c结尾的所有元素。

li = ["alec", " aric", "Alex", "Tony", "rain"]
for i in li:
    i = i.strip()
    if i.startswith('a') or i.startswith('A') and i.endswith('c'):
        print(i)

tu = ("alec", " aric", "Alex", "Tony", "rain")
for i in tu:
    i = i.strip()
    if i.startswith('a') or i.startswith('A') and i.endswith('c'):
        print(i)

dic = {'k1': "alex", 'k2': ' aric', "k3": "Alex", "k4": "Tony"}
for v in dic.values():
    v = v.strip()
    if v.startswith('a') or v.startswith('A') and v.endswith('c'):
        print(v)

3. 写代码，有如下列表，按照要求实现每一个功能
   li＝['alex', 'eric', 'rain']

• 计算列表长度并输出
• 列表中追加元素“seven”，并输出添加后的列表
• 请在列表的第1个位置插入元素“Tony”，并输出添加后的列表
• 请修改列表第2个位置的元素为“Kelly”，并输出修改后的列表
• 请删除列表中的元素“eric”，并输出修改后的列表
• 请删除列表中的第2个元素，并输出删除的元素的值和删除元素后的列表
• 请删除列表中的第3个元素，并输出删除元素后的列表
• 请删除列表中的第2至4个元素，并输出删除元素后的列表
• 请将列表所有的元素反转，并输出反转后的列表
• 请使用for、len、range输出列表的索引
• 请使用enumrate输出列表元素和序号（序号从100开始）
• 请使用for循环输出列表的所有元素

li = ['alex', 'eric', 'rain']

print(len(li))

li.append('seven')
print(li)

li.insert(0, 'Tony')
print(li)

li.insert(1, 'Kelly')
print(li)

li.remove('eric')
print(li)

print(li[1])
del li[1]
print(li)

del li[2]
print(li)

del li[1:4]
print(li)

li.reverse()
print(li)

for k, v in enumerate(li, 100):
    print(v, k)

for i in range(

4. 写代码，有如下列表，请按照功能要求实现每一个功能

'''
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]

- 请根据索引输出“Kelly”
- 请使用索引找到'all'元素并将其修改为“ALL”，如：li[0][1][9]...
'''

li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
print(li[2][1][1])
li[2][2] = li[2][2].upper()
print(li)

5. 写代码，有如下元组，请按照功能要求实现每一个功能

'''
计算元组长度并输出
获取元组的第2个元素，并输出
获取元组的第1-2个元素，并输出
请使用for输出元组的元素
请使用for、len、range输出元组的索引
请使用enumrate输出元祖元素和序号（序号从10开始）
'''
tu = ('alex', 'eric', 'rain')

print(len(tu))
print(tu[1])
print(tu[0:2])

for i in tu:
    print(i)

for i in range(0, len(tu)):
    print(i)

for k,v in enumerate(tu, 10):
    print(v, k)

6. 有如下变量，请实现要求的功能

"""
讲述元祖的特性
请问tu变量中的第一个元素“alex”是否可被修改？
请问tu变量中的"k2"对应的值是什么类型？是否可以被修改？如果可以，请在其中添加一个元素“Seven”
请问tu变量中的"k3"对应的值是什么类型？是否可以被修改？如果可以，请在其中添加一个元素“Seven”
"""
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11, 22, 33)}, 44])

"元组是不可变的有序列表"

"k2对应的类型是列表，可以更改"
tu[1][2]["k2"].append("Seven")

"k3对应的元素类型是元组，不可以被更改"

7. 字典

"""
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}

请循环输出所有的key
请循环输出所有的value
请循环输出所有的key和value
请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
请在修改字典中“k1”对应的值为“alex”，输出修改后的字典
请在k3对应的值中追加一个元素44，输出修改后的字典
请在k3对应的值的第1个位置插入个元素18，输出修改后的字典
"""
dic = {'k1': "v1", "k2": "v2", "k3": [11, 22, 33]}

for k in dic.keys():
    print(k)

for v in dic.values():
    print(v)

for k,v in dic.items():
    print(k, v)

dic['k4'] = 'v4'
print(dic)

dic['k1'] = 'alex'
print(dic)

dic['k3'].append(44)
print(dic)

dic['k3'].insert(0, 18)
print(dic)

8. 转换

# 将字符串s = "alex"转换成列表
s = "alex"
print(list(s))
# 将字符串s = "alex"转换成元祖
s = "alex"
print(tuple(s))
# 将列表li = ["alex", "seven"]转换成元组
li = ["alex", "seven"]
print(tuple(li))
# 将元祖tu = ('Alex', "seven")转换成列表
tu = ('Alex', "seven")
print(list(tu))
# 将列表li = ["alex", "seven"]转换成字典且字典的key按照10开始向后递增
li = ["alex", "seven"]
print(dict(zip(range(10, len(li) + 10), li)))

9. 元素分类

# 有如下值集合[11,22,33,44,55,66,77,88,99,90]，将所有大于66的值保存至字典的第一个key中，将小于66的值保存至第二个key的值中。
#
# 即：{'k1':大于66的所有值, 'k2':小于66的所有值}

li = [11, 22, 33, 44, 55, 66, 77, 88, 99, 90]

d = {
    'k1': [],
    'k2': []
}

for i in li:
    if i > 66:
        d['k1'].append(i)
    elif i< 66:
        d['k2'].append(i)

print(d)

10. 输出商品列表，用户输入序号，显示用户选中的商品

# 输出商品列表，用户输入序号，显示用户选中的商品
#
# 商品li = ["手机", "电脑", '鼠标垫', '游艇']
#
# 允许用户添加商品
# 用户输入序号显示内容

li = ["手机", "电脑", '鼠标垫', '游艇']

while True:
    print("list".center(80, '-'))
    for k, v in enumerate(li):
        print(k, v)
    user_choice = input("请选择商品,(a 添加商品, q 退出)>>> ").strip()
    if user_choice.isdigit():
        user_choice = int(user_choice)
        if 0 <= user_choice < len(li):
            print(li[user_choice])
        else:
            print("商品不存在!")
    elif user_choice == 'a':
        user_product = input("请输入你想添加的商品>>> ").strip()
        li.append(user_product)
    elif user_choice == 'q':
        break
    else:
        print("输入错误，请重新输入～")

11. 用户交互显示类似省市县N级联动的选择

# 允许用户增加内容
# 允许用户选择查看某一个级别内容

12. 列举布尔值是False的所有值
    None 0 [] {}
13. 有两个列表

# l1 = [11,22,33]
#
# l2 = [22,33,44]
#
# 获取内容相同的元素列表
# 获取l1中有，l2中没有的元素列表
# 获取l2中有，l3中没有的元素列表
# 获取l1和l2中内容都不同的元素

l1 = [11, 22, 33]
l2 = [22, 33, 44]

set1 = set(l1)
set2 = set(l2)

print(set1.intersection(set2))
print(set1.difference(set2))
print(set2.difference(set1))
print(set1.symmetric_difference(set2))

14. 利用For循环和range输出

# For循环从大到小输出1 - 100
for i in range(1, 101):
    print(i)
# For循环从小到到输出100 - 1
for i in range(0, 100):
    print(100 - i)
# While循环从大到小输出1 - 100
count = 1
while count <= 100:
    print(count)
    count += 1
# While循环从小到到输出100 - 1
count = 100
while count > 0:
    print(count)
    count -= 1

15. 利用for循环和range输出9 * 9乘法表

for i in range(1, 10):
    for j in range(1, 10):
        print("%s * %s = %s" % (j, i, i*j),end="\t")
    print()

16. 求100以内的素数和。（编程题）

sum = 0
for i in range(1, 100):
    if i == 1:
        continue
    for j in range(2, i):
        if i % j == 0:
            break
    else:
        sum += i
        print(i)

print(sum)

17. 将[1,3,2,7,6,23,41,24,33,85,56]从小到大排序(冒泡法)

li = [1, 3, 2, 7, 6, 23, 41, 24, 33, 85, 56]

for i in range(0, len(li) - 1):
    if li[i] > li[i + 1]:
        li[i], li[i + 1] = li[i + 1], li[i]

print(li)