Python的 100道題目

本應該是100道，因不可抗力變成97道

#-*- coding:utf-8 -*-

#1. 計算2的3次⽅
# a = input("請輸入底數：")
# b = input("請輸入指數：")
# def mi(a,b):
#
#     c = a**b
#     print c
#
# # mi(a,b)
# # x = input("請輸入底數：")
# # n = input("請輸入指數：")
#
# def power(x,n):
#     s =1
#     while n > 0:
#         n = n -1
#         s = s * x
#     return s
# p = power(2,8)
# print p

print (pow(2,5))

# 2. 找出序列中的最⼤最⼩值
li = [12,56,2,88,68,26,14,799]
a = max(li)
b = min(li)
print a, b

# 3.將字元列表轉為字串
# l = [12,56,2,88,68,26,14,799]
# print(str(l))
# print(type(str(l)))

# join() 方法用於將序列中的元素以指定的字元連線生成一個新的字串
strList = ["zhangweijian","is ","a","good  Boy"]
st = " ".join(strList)
print st

# 4. 快速列印出包含所有 ASCII 字⺟（⼤寫和⼩寫）的字串
import string
print string.ascii_letters

# 5.讓字串居中
# 字串中的 center ⽅法，他會在兩邊⾃動填充字元（預設為空格），讓字串居zhong
cen = "zhangweijian"
print(cen.center(20))
print(cen.center(30,'*'))

# 6.在字串中找到⼦串
# find ⽅法，如果找到，就返回⼦串的第⼀個字元的索引，否則返回 -1
str1 = "zhang wei jian is a good boy"
print(str1.find("jian"))
print(str1.find("n"))
print(str1.find("a"))
print(str1.find("ian"))
print(str1.find("ang"))

# 7. 讓字元的⾸字⺟⼤寫，其他字⺟⼩寫
# title ⽅法
str2 = "zhang"
print(str2.title())

# ⽤ string 模組⾥的 capwords ⽅法
print(string.capwords(str2))

# 8.清空列表內容

#⽤ clear ⽅法
list1 = {12,56,2,88,68,26,14,799}       #//集合
print(list1.clear())

# ⽤切⽚賦值的⽅法
list2 = [12,56,2,88,68,26,14,799]
list2[:] = []
print list2

# 9.計算指定的元素在列表中出現了多少次
#count ⽅法
list3 = [12,56,2,88,68,26,14,799,2,56,2,89,14,2,2]
print(list3.count(2))


# 10.在列表末尾加⼊其它元素
list4 = [12,56,2,88,68,26,14,799,2,56,2,89,14,2,2]
list5 = [33,44,55]
lis = list4.extend(list5)
print(list4)
print(list4.append( "zhang"))
print list4

#extend 和列表相加的區別
# extend 是直接在 list4 列表⾥加⼊元素，相加會⽣成⼀個新元素，並不會對 list4 做修改
list6 = [100,200,300]
lis2 = list4 + list6
print lis2
print list4

# 11.查詢列表中某個元素第⼀次出現的索引，從0 開始
list7 = [12,56,2,88,68,26,14,799,2,56,2,89,14,2,2]
print(list7.index(26))

# 12.將⼀個物件插⼊到列表中
list8 = [12,56,2,88,68,26,14,799,2,56,2,89,14,2,2]
list8.append(9999)
print list8
list8.insert(4,1777)
print list8

# 用切片的方式
list8[2:3] = [666]      # 佔掉了index 為2 的值
print(list8)
list8[2:2] = [777]
print(list8)

# 13.刪除列表中元素

# 刪除指定元素   remove ⽅法只會刪除第⼀次出現的元素
list8.remove(12)
print(list8)

# pop ⽅法可以刪除指定元素，不指定位置的話預設刪除最後⼀個元素
print(list8.pop())
print(list8.pop(2))
print(list8)

# 14.讓列表按相反順序排列
list8.reverse()
print list8

# 用切片方式
print list8

print list8[::-1]

# 15.表示只包含⼀個元素的元組
tu = (5,)
print(type(tu))

# 16.批量替換字串中的元素
str3 = 'zhang wei jian'

print(str3.replace('a','mm'))

print (str3.replace('a','jj',1))

# 17.把字串按照空格進⾏拆分
# ⽤ split ⽅法，括號為空的情況下預設以空格拆分
print(str3.split(' '))
print(str3.split())

# 18.去除字串⾸位的空格
str4 = ' zhang wei jian '
print str4
print (str4.strip())

# 19. 給字典中不存在的key指定 預設值
dict1 = {1 :'a', 2 :'b', 3 :'c'}
print(dict1.get(2,'bb'))
print(dict1.get(4,'mm'))

# 20.快速求 1 到 100 所有整數相加之和
print(sum(range(1,101)))

# 21.查出模組包含哪些屬性
#dir ⽅法
dir()
import requests
dir(requests)

# 22.快速檢視某個模組的幫助⽂檔
range.__doc__

# 23.快速啟動瀏覽器開啟指定⽹站
# ⽤ webbrowser 庫
import webbrowser
webbrowser.open('http://www.python.org')

# 24.Python⾥佔位符怎麼表示？
pass
#⽤ pass 佔位，當你還沒想好程式碼塊的邏輯時，你需要運⾏程式碼除錯其他功能，需要加佔位符，不然會報錯

# 25.給函式編寫⽂檔
# 在 def 語句後⾯把註釋⽂檔放在引號（單引、雙引、三引都可以）⾥⾯就⾏，這個⽂檔可以通過 function.__doc__訪問
def square(x):
    '''返回平方值'''
    return x*x

square.__doc__

# 26.定義私有⽅法
## 在⽅式名稱前加兩個下斜槓 __
class Person:
    def __name(self):
        print('私有⽅法')
#### ⽤ from module import * 導⼊時不會導⼊私有⽅法

# 27.判斷⼀個類是否是另⼀個類的⼦類
## ⽤ issubclass ⽅法，2 個引數，如果第⼀個引數是第⼆個引數的⼦類，返回 True，否則返回 False

class A:
 pass
class B(A):
 pass
issubclass(B, A)  # True

# 28.從⼀個⾮空序列中隨機選擇⼀個元素
## ⽤ random 中的 choice ⽅法
import random
print(random.choice(list8))
print(random.choice(['uu',34,'aa',55,78,'dd','bb']))

# 29.查出通過 from xx import xx導⼊的可以直接調⽤的⽅法
##  all ⽅法，這個⽅法查出的是模組下不帶_的所有⽅法，可以直接調⽤
print(random.__all__)

# 30.花括號{} 是集合還是字典?
## 字典
type({})  #  <class 'dict'>

# 31. 求兩個集合的並集
## 1.解法1:⽤ union ⽅法
dict2 = {6,7,8,9}
dict3 = {8,9,1,2}
print(dict2.union(dict3))     # set([1, 2, 6, 7, 8, 9])

## 2.解法2:使⽤按位或運算子 ｜
print(dict2 | dict3)

# 32.求兩個集合的交集
## 1. 解法一
print(dict2 & dict3)
## 2.解法2:⽤ intersection ⽅法
print(dict2.intersection(dict3))

# 33.求兩個集合中不重複的元素
#差集指的是兩個集合交集外的部分
## 1.使⽤運算子 ^
print(dict2 ^ dict3)

## 2.解法2:使⽤ symmetric_difference ⽅法
print(dict2.symmetric_difference(dict3))

# 34.求兩個集合的差集
## 解法1:⽤運算子 -
print(dict2 - dict3)
print(dict3 - dict2)

## 解法2:⽤ difference ⽅法
print(dict2.difference(dict3))

# 35. 從⼀個序列中隨機返回 n 個不同值的元素
## ⽤ random 中的 sample ⽅法
print(random.sample(list8, 3))

# 36.⽣成兩個數之間的隨機實數
## ⽤ random 中的 uniform ⽅法
print(random.uniform(10,100))

# 37.在等差數列中隨機選擇⼀個數
## ⽤ random 中的 randrange ⽅法
print(random.randrange(0,100,5))

# 38. 在⽂件⾥寫⼊字元
## ⽤ open 函式，模式⽤ w
with open('bruce.txt', 'w') as f:
    f.write('hello world')

# 39.讀取⽂件內容
## ⽤ open 函式，模式⽤ r（預設情況下是 r)
with open('bruce.txt', 'r') as f:
    f.read()

## 'hello world'

# 40.把程式打包成 exe ⽂件
## 安裝py2app

'''
pip3 install py2app
cd 到Demo.py⽂件所在的⽬錄
py2applet --make-setup Demo.py 完成顯示⽣成setup.py
'''

# 41.獲取路徑下所有⽬錄名稱
## ⽤ sys 下的 path ⽅法，返回的是⽬錄名稱的字串列表
import sys
sys.path

# 42.Python 環境下怎麼執⾏作業系統命令
## ⽤ os 模組下的 system ⽅法
import os
#  os.system('cd /Users/brucepk/Desktop && mkdir aaa.txt')


# 43.麼將當前時間轉為字串
## ⽤ time 模組⾥的 asctime ⽅法
import time
print(time.asctime())

# 44.將秒數轉為時間陣列
## ⽤ time 模組⾥的 localtime ⽅法
print(time.localtime())
print(time.localtime(18888888888))

# 45.將時間元組轉換為從新紀元後的秒數
## ⽤ time 模組⾥的 mktime ⽅法
print(time.mktime((2020, 7, 3, 21, 48, 56, 4, 21, 0)))

# 46.將字串轉為時間元組
## ⽤ time 模組⾥的 strptime ⽅法
print(time.strptime('Thu Nov 19 00:05:31 2020'))

# 47.隨機打亂列表的順序
## ⽤ random 模組⾥的 shuffle ⽅法
list9 = list(range(20))
print(list9)

random.shuffle(list9)
print list9

#############################################    Python進階習題   ###########################################
# 48. ⽤for迴圈實現把字串變成Unicode碼位的列表
## ord() 函式是 chr() 函式（對於 8 位的 ASCII 字串）的配對函式，它以一個字串（Unicode 字元）作為引數，返回對應的 ASCII 數值，或者 Unicode 數值。
st =  '!@#$%^&*'
codes = []
for i in st:
    codes.append(ord(i))
print codes

# 49.⽤列表推導式實現把字串變成Unicode碼位的列表
## ⽤列表推導式實現⽐ for 迴圈加 append 更⾼效簡潔，可讀性更好。
st1 = '!@#$%^&*'
codes1 = [ord(s) for s in st]
print(codes1)

# 50.列印出兩個列表的笛卡爾積
## 解法1:使⽤⽣成器表示式產⽣笛卡爾積，可以幫忙省掉運⾏ for 迴圈的開銷。
colors = ['blacks', 'white']
sizes = ['S', 'M', 'L']
for tshirt in ('%s %s'%(c, s) for c in colors for s in sizes):
    print tshirt

## 解法2:使⽤ itertools ⾥的 product ⽣成器函式。
import itertools
print(list(itertools.product(['blacks', 'white'], ['S', 'M', 'L'])))

# 51. 可迭代物件拆包時，怎麼賦值給佔位符
## 我們經常⽤ for 迴圈提取元組⾥的元素，對於我們不想接收的元素，我們可以⽤佔位符 _ 接收。
player_infos = [('Kobe', '24'), ('James', '23'), ('Iverson','3')]
for player_names, _ in player_infos:
    print(player_names)

for _, player_values in player_infos:
    print(player_values)

# 52.Python3 中，⽤什麼⽅式接收不確定值或引數
## ⽤ *args 的⽅式，*args 位置可以在任意位置。
# a, b, *c = range(8)
# >>> a, b, c
# (0, 1, [2, 3, 4, 5, 6, 7])

# >>> a, *b, c, d = range(5)
# >>> a,b,c,d
# (0, [1, 2], 3, 4)

# >>> *a, b, c, d = range(5)
# >>> a,b,c,d
# ([0, 1], 2, 3, 4)

# 53.⽤切⽚講物件倒序
s = 'basketball'
print(s[::-1])

# 54.檢視列表的 ID

print(id(list8))

# 55.可變序列⽤*=（就地乘法）後，會建立新的序 列嗎？
## 不會，可變序列⽤*=（就地乘法）後，不會建立新的序列，新元素追加到⽼元素上，以列表為例，我們看下新⽼列表的id，相等的。

'''
>>> l = [1, 2, 3]
>>> id(l)
4507939272
>>> l *= 2
>>> l
[1, 2, 3, 1, 2, 3]
>>> id(l)
4507939272
'''

# 56.不可變序列⽤*=（就地乘法）後，會建立新的序列嗎？
## 會，不可變序列⽤*=（就地乘法）後，會建立新的序列，以元組為例，我們看下新⽼元組的id，是不同的。
'''
>>> t = (1, 2, 3)
>>> id(t)
4507902240
>>> t *= 2
>>> t
(1, 2, 3, 1, 2, 3)
>>> id(t)
4507632648
'''

#######  究極原因
### 所以，對不可變序列進⾏重複拼接操作的話，效率會很低，因為每次都有⼀個新物件，⽽直譯器需要把原來物件中的元素先複製到新的物件⾥，然後再追加新的元素

# 57.關於+=的⼀道謎題
'''
t = (1, 2, [30, 40])
t[2] += [50, 60]
'''

'''
到底會發⽣下⾯4種情況中的哪⼀種？
a. t變成(1, 2, [30, 40, 50, 60])。
b.因為tuple不⽀持對它的元素賦值，所以會丟擲TypeError異常。
c.以上兩個都不是。
d. a和b都是對的。
答案是d，請看下運⾏結果。
>>> t = (1, 2, [30, 40])
>>> t[2] += [50, 60]
Traceback (most recent call last):
 File "<pyshell#1>", line 1, in <module>
 t[2] += [50, 60]
TypeError: 'tuple' object does not support item assignment
>>> t
(1, 2, [30, 40, 50, 60])

'''

# 58.sort() 和 sorted() 區別
l = [1, 9, 5, 8]
j = l.sort()
k = sorted(l)
print l
print k
### sort() 會就地在原序列上排序，sorted() 新建了⼀個新的序列。
'''
list.sort⽅法會就地排序列表，也就是說不會把原列表複製⼀份。這也是這個⽅法的
返回值是None的原因，提醒你本⽅法不會新建⼀個列表。在這種情況下返回None
其實是Python的⼀個慣例：如果⼀個函式或者⽅法對物件進⾏的是就地改動，那它
就應該返回None，好讓調⽤者知道傳⼊的引數發⽣了變動，⽽且並未產⽣新的對
象。
'''

# 59.通過 reverse 引數對序列進⾏降序排列
'''
reverse 引數⼀般放在 sorted() ⽅法⾥⾯，reverse 預設值為 False，序列預設升序
排列，降序排列的話需要將 reverse 值設定為 True。
'''
l1 = [8,3,5,1,6,9]
j1 = sorted(l1, reverse=True)
print j1

# 60.numpy 怎麼把⼀維陣列變成⼆維陣列
'''
>>> a = numpy.arange(12)
>>> a
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
>>> a.shape = 3, 4
>>> a
array([[ 0, 1, 2, 3],
 [ 4, 5, 6, 7],
 [ 8, 9, 10, 11]])
'''

# 61.快速插⼊元素到列表頭部
## 可以通過切⽚指定位置插⼊，頭部就是[0:0]
l2 = [1,2,3,4,5,6]
l2[0:0] = 'zhang'
print l2

## 還可以通過 insert() ⽅法插⼊，第⼀個引數是位置的座標，從 0 開始。
l2.insert(0,'wei')
print l2
'''
在第⼀個元素之前新增⼀個元素之類的操作是很耗時的，因為這些操作會牽扯到移
動列表⾥的所有元素。有沒有更⾼效的⽅法？⽤雙向佇列 deque 類。
deque 類可以指定這個佇列的⼤⼩，如果這個佇列滿員了，還可以從反向端刪除過
期的元素，然後在尾端新增新的元素
'''
from collections import deque

dp = deque(range(10), maxlen=15)
print dp
dp.appendleft(-1)
print dp

# 62. 字典的建立⽅法
a = dict(one=1, two=2, three=3)
b = {'one': 1, 'two': 2, 'three': 3}
c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
d = dict([('two', 2), ('one', 1), ('three', 3)])
e = dict({'one': 1, 'two': 2, 'three': 3})
print a,b,c,d,e


## ⽤字典推導（dictcomp）構建字典
dial_code = [
 (86, 'China'),
 (91, 'India'),
 (1, 'US'),
 (55, 'Brazil'),
 (7, 'Russia'),
 (81, 'Japan') ]
coutry_code = {coutry:code for code, coutry in dial_code}
print coutry_code

## 63.通過⼀次查詢給字典⾥不存的鍵賦予新值
### ⽤setdefault⽅法，只查詢⼀次，效果更快
coutry_code = {'China': 86, 'India': 91, 'US': 1, 'Brazil': 55,
'Russia': 7, 'Japan': 81}
coutry_code.setdefault('china', []).append(86)
print coutry_code
### 如果⽤下⾯這種⽅法，需要查詢三次
if 'china' not in coutry_code:
 coutry_code['china'] = []
 coutry_code['china'].append(86)
print(coutry_code)

'''
像k in my_dict.keys（　）這種操作在Python 3中是很快的，⽽且即便對映型別對
象很龐⼤也沒關係。這是因為dict.keys（　）的返回值是⼀個“檢視”。檢視就像⼀
個集合，⽽且跟字典類似的是，在檢視⾥查詢⼀個元素的速度很快。在“Dictionary
view objects”⾥可以找到關於這個細節的⽂檔。Python 2的dict.keys（　）返回的
是個列表，因此雖然上⾯的⽅法仍然是正確的，它在處理體積⼤的物件的時候效率
不會太⾼，因為k in my_list操作需要掃描整個列表。
'''

## 64.統計字串中元素出現的個數？
## ⽤collections中的Counter⽅法統計，返回的結果是對應元素和個數形成的鍵值對。
import collections
ct = collections.Counter('adcfadcfgbsdcv')
print ct

'''
怎麼統計出排名前n的元素？
⽤most_common⽅法，引數⾥填n，⽐如前兩名的話
'''
cd = ct.most_common(2)
print cd

## 65.列表去重
l3 =  ['A', 'B', 'A', 'B']
ll3 = list(set(l3))
print ll3

# 66.求m中元素在n中出現的次數
## 基礎解法：
m = {'A', 'B', 'C'}
n = {'B', 'C', 'D'}
found = 0
for i in m:
    if i in n:
        found += 1
print found

## ⾼級解法：
print(len(m&n))

### 如果m和n不是集合的話，直接轉換後再取交集
print(len(set(m) & set(n)))
## ⾼級解法的另⼀種寫法：
print( len(set(m).intersection(n)))

# 67. 新建⼀個Latin-1字符集合，該集合⾥的每個字元的Unicode名字⾥都有“SIGN”這個單詞,⽤集合推導式完成。
from unicodedata import name
# print ({chr(i) for i in range(32, 256) if 'SIGN' in name(chr(i), '')})

# 68. 查詢系統預設編碼⽅式
import sys
sys.path.append('./')
fp = open('test.txt', 'w')
print fp.encoding

# 修改編碼方式
#fp = open('test.txt', 'w', encoding='utf-8')
#print fp.encoding

# 69. ⽤遞迴實現階乘
def factorial(n):
 """:return n!"""
 return 1 if n < 2 else n * factorial(n-1)
fa  = factorial(10)
print fa

# 70. all([])的輸出結果是多少？
True

# 71.  any([])的輸出結果是多少?
False

# 72.判斷物件是否可被調⽤？
#⽤ Python 內建的函式 callable() 判斷
print [callable(obj) for obj in (abs, str, 2)]

# 73.列出物件的所有屬性
## 使⽤ dir 函式來獲取物件的所有屬性。
import requests
print(dir(requests))

# 74.怎麼得到類的例項沒有⽽函式有的屬性列表
## 建立⼀個空的⽤戶定義的類和空的函式，計算差集，然後排序。
class C:
  pass

obj = C()
def func():
  pass

print sorted(set(dir(func)) - set(dir(obj)))

# 75.函式中，不想⽀持數量不定的定位引數，但是想⽀持僅限關鍵字引數，引數怎麼定義
## 那就要在關鍵字引數前加⼀個 *。
def f(a, **b):
  return a,b
ff = f(1, b=2)
print ff
# 這樣的話，b 引數強制必須傳⼊實參，否則會報錯

# 76.怎麼給函式引數和返回值註解
'''
程式碼執⾏時，註解不會做任何處理，只是儲存在函式的__annotations__屬性（⼀個
字典）中
'''
## def function(text: str, max_len: 'int > 0' = 80) -> str:

'''
函式宣告中的各個引數可以在:之後增加註解表示式。如果引數有預設值，註解放在
引數名和=號之間。如果想註解返回值，在)和函式宣告末尾的:之間新增->和⼀個表
達式。
Python對註解所做的唯⼀的事情是，把它們儲存在函式的__annotations__屬性⾥。
僅此⽽已，Python不做檢查、不做強制、不做驗證，什麼操作都不做。換句話說，
註解對Python直譯器沒有任何意義。註解只是後設資料，可以供IDE、框架和裝飾器
等⼯具使用
'''
# 77.不使⽤遞迴，怎麼⾼效寫出階乘表示式
## 通過 reduce 和 operator.mul 函式計算階乘
from functools import reduce
from operator import mul
def fact(n):
  return reduce(mul, range(1, n+1))
fa = fact(5)
print fa

# 78.Python什麼時候執⾏裝飾器？
## 函式裝飾器在導⼊模組時⽴即執⾏，⽽被裝飾的函式只在明確調⽤時運⾏。這突出了Python程式設計師所說的導⼊時和運⾏時之間的區別。


# 79.判斷下⾯語句執⾏是否會報錯？
'''
>>> b = 3
>>> def fun(a):
      print(a)
      print(b)
      b = 7
 
>>> fun(2)

會報錯，Python編譯函式的定義體時，先做了⼀個判斷，那就是 b 是區域性變數，因
為在函式中給它賦值了。但是執⾏ print(b) 時，往上⼜找不到 b 的區域性值，所以會
報錯
Python 設計如此，Python 不要求宣告變數，但是假定在函式定義體中賦值的變數
是區域性變數。

2
Traceback (most recent call last):
 File "<pyshell#50>", line 1, in <module>
 fun(2)
 File "<pyshell#49>", line 3, in fun
 print(b)
UnboundLocalError: local variable 'b' referenced before assignment
'''
# 80.怎麼強制把函式中區域性變數變成全域性變數
## ⽤ global 宣告
'''
>>> b = 3
>>> def fun(a):
      global b
      print(a)
      print(b)
      b = 7
>>> b = 5
>>> fun(2) 
2
5
'''
# 81.閉包中，怎麼對數字、字串、元組等不可變元素更新
## 我們知道，在閉包中，宣告的變數是區域性變數，區域性變數改變的話會報錯。
'''
>>> def make_averager():
      count = 0
      total = 0
   def averager (new_value):
      count += 1
      total += new_value
      return total / count
   return averager
>>> avg = make_averager()
>>> avg(10)
Traceback (most recent call last):
 File "<pyshell#63>", line 1, in <module>
 avg(10)
 File "<pyshell#61>", line 5, in averager
 count += 1
UnboundLocalError: local variable 'count' referenced before
assignment

為了解決這個問題，Python 3引⼊了 nonlocal 宣告。它的作⽤是把變數標記為⾃由
變數

'''

'''
>>> def make_averager():
      count = 0
      total = 0
   def averager (new_value):
      nonlocal count, total
      count += 1
      total += new_value
      return total / count
   return averager

>>> avg = make_averager()
>>> avg(10)
10.0
'''

# 82.Python2 怎麼解決訪問外部變數報錯的問題
'''
https://www.python.org/dev/peps/pep-3104/
'''

# 83.測試程式碼運⾏的時間
## ⽤ time 模組⾥的 perf_counter ⽅法
'''
python2.7 不支援該種寫法，python3 支援
import time
t0 = time.perf_counter()
for i in range(1000):
  pass

t1 = time.perf_counter()
print t1 - t0
'''
## 或者，直接⽤ time.time()

t2 = time.time()
for i in range(1000):
  pass
t3 = time.time()

print t3 - t2


# 84. 怎麼優化遞迴演算法，減少執⾏時間
## 使⽤裝飾器 functools.lru_cache() 快取資料, 同樣適用於python3以上版本
'''
import functools
@functools.lru_cache()
def fibonacci(n):
  if n < 2:
    return n 
  return fibonacci(n-2)+fibonacci(n-1)
print fibonacci(6)

標準庫singledispatch官⽅⽂檔：https://www.python.org/dev/peps/pep-0443/
'''
# 85. ⽐較兩個物件的值（物件中儲存的資料）是否相 等
## ⽤ == 運算子⽐較
l6 = [1,2,3]
l7 = [1,2,3]
print l6==l7

# 86.⽐較兩個物件的記憶體地址 id 是否相等
## ⽤ is ⽐較，ID⼀定是唯⼀的數值標註，⽽且在物件的⽣命週期中絕不會變
print l6 is l7

# 87.怎麼格式化顯示物件？
'''
可以⽤內建的 format（　）函式和str.format（　）⽅法。
format(my_obj, format_spec)的第⼆個引數，或者str.format（　）⽅法的格式字元
串，{}⾥代換欄位中冒號後⾯的部分。
'''
from datetime import datetime
now = datetime.now()
print format(now,'%H:%M:%S')
form =  "It's now {:%I:%M%p}".format(now)
print form

# 88.複製⼀個序列並去掉後 n 個元素
'''
可能有同學會想到⽤ pop()，但這個⽅法會就地刪除原序列，不會複製出⼀個新的
序列。
可以⽤切⽚的思想，⽐如複製後去掉後兩個元素
'''
l8 = [1,2,3,4,5]
j2 = l8 [:-2]
print j2


# 89.Python中怎麼定義私有屬性。
## 在屬性前加兩個前導下劃線，尾部沒有或最多有⼀個下劃線

# 90. 怎麼隨機打亂⼀個列表⾥元素的順序
## ⽤ random ⾥的 shuffle ⽅法
from random import shuffle
l9 = list(range(30))
shuffle(l9)
print l9

# 91. 怎麼判斷某個物件或韓式是⼀個已知的型別
## ⽤ Python 的內建函式 isinstance() 判讀
print  isinstance('aa', str)

# 92. 怎麼列印出分數
## ⽤ fractions 中的 Fraction ⽅法
from fractions import Fraction
print Fraction(1,3)

# 93.  + 和 += 區別
## 兩邊必須是同型別的物件才能相加，+= 右運算元往往可以是任何可迭代物件。
l0  = list(range(6))
l0 += 'qwer'
print l0

'''
 j = l0 + (6, 7)
Traceback (most recent call last):
 File "<pyshell#91>", line 1, in <module>
 j = l0 + (6, 7)
TypeError: can only concatenate list (not "tuple") to list
'''
# 94. 怎麼列出⼀個⽬錄下所有的⽂件名和⼦⽂件名
## ⽤ os.walk ⽣成器函式，我⽤ site-packages ⽬錄舉例
import os
dirs = os.walk('/home/zhangweijian/PythonProject/prac_one')
for dir in dirs:
  print dir

# 95.返回 1 到 10 的階乘列表
## ⾼效的⽅法需要⽤到 itertools 和 operator 模組，導包後⼀⾏程式碼搞定。
import itertools
import operator
# print  list(itertools.accumulate(range(1, 11), operator.mul))

# 96.怎麼快速拼接字串和序列形成新的列表
## ⽤ itertools ⾥的 chain ⽅法可以⼀⾏程式碼搞定
import itertools
print list(itertools.chain('ABC', range(5)))


# 97. 進度條顯示
## ⽤ tqdm 庫

import time
from tqdm import tqdm
for i in tqdm(range(1000)):
  time.sleep(.01)