一，變量

1，什么是變量之聲明變量

變量名=變量值

name= ‘egon’?????? age = 18?????? sex = ‘female‘?? 等

2，為什么要有變量

變量作用：變==》變化，?? 量===》衡量，計量/保存狀態

程序運行本質是一系狀態變化，變化的目的就是用來保存狀態，變量值的變化就構成了程序運行的不同結果。

3，變量值之類型與對象

程序中需要處理的狀態很多，有了不同類型的變量值，x = ‘egon’，變量值‘egon’的存放于內存中，綁定一個名字x，變量及我們要存儲的數據

4，可變對象與不可變對象

可變對象：本身可以被其他方法或手段改變的

不可變對象：本身不可以被改變的

5，容器對象：包含其他對象的引用，稱為容器或集合

6，對象的屬性和方法

對象屬性就是對象值，方法----能夠調用這些方法能夠使原來的對象發生變化

7，變量的賦值操作

1，鏈式賦值：y = x = a =1

2，多元賦值：x，y=1,2，x，y=y，x

3，增量賦值：x+=1

python 中的數據類型

python使用對象模型來存儲數據，每一個數據類型都有一個內置方法，每新建一個數據，就是初始化一個對象，即及所有數據都是對象

對象的三個特性??? id----地址????????? 類型-------type??????? 值------value

注意：當我們定義?? name = ‘金星’?? 時，內部就會生成這一內存對象(觸發)

標準數據類型

*****在python中所有數據都是圍繞對象這個概念來構建的，對象包含一些基本的數據類型，數字，字符串，列表，字典，元組，集合等。

二，數字類型

定義：a = 1

特性：1，只能存放一個值????? 2，一經定義不可更改??? 3，直接訪問

分類：整型(int)，長整型(long)，布爾(bool)，浮點(folat)，復數(complex)

****python2與python3的不同

***注：在python3中沒有長整形long，如果字符串過長，python3會自動默認為長整形

在python2中有：整形(int)和長整形long

int：整形，數字運算(python中的整數可以用十進制，八進制，十六進制表示)

>>> 10

10 --------->默認十進制

>>> oct(10)

'012' --------->八進制表示整數時，數值前面要加上一個前綴“0”

>>> hex(10)

'0xa' --------->十六進制表示整數時，數字前面要加上前綴0X或0x

三，bool(布爾)類型

布爾值就兩種：True，False。就是反應條件的正確與否。

真 ? 1 ? True。

假 ? 0 ? False。

四，?字符串?? (Str = ‘abc’，用單引號或雙引號引起來的數據就是字符串)

定義：是一個有序的字符集合，用于存儲少量或單個數據。是不可變類型，按照從左至有的順序定義字符集合，下標是從零開始。有序

*****字符串常用操作：

移除空白，分隔，長度，索引，切片

索引即下標，就是字符串組成的元素從第一個開始，初始索引為0以此類推。

a = 'ABCDEFGHIJK'

print(a[0])

print(a[3])

print(a[5])

print(a[7])

切片就是通過索引(索引：索引：步長)截取字符串的一段，形成新的字符串(原則就是顧頭不顧腚)。

a = 'ABCDEFGHIJK'

print(a[0:3])

print(a[2:5])

print(a[0:]) #默認到最后

print(a[0:-1]) #-1就是最后一個

print(a[0:5:2]) #加步長 print(a[5:0:-2]) #反向加步長

print(a[:]) 什么都不寫，方括號中只寫：，就可以復制一個原來的字符串或列表等

字符串常用內置方法：

# 1，find通過元素找索引，可切片，找不到返回-1#2，index，求索引，找不到報錯。

#3，split 由字符串分割成列表，默認按空格。

#4，captalize 首字母大寫，其他字母小寫。

#5，upper 全大寫。

#6，lower 全小寫。

#7，title，每個單詞的首字母大寫。

#8，startswith 判斷以什么為開頭，可以切片，整體概念。

#9，endswith 判斷以什么為結尾，可以切片，整體概念。

#10，format：格式化

# {}{}{}.format(有順序)

# {0}{1}{2}{0}.format(有順序的)

#'{name} {age}'.format(name=李復，age=12)

#11, strip 默認去掉兩側空格，有條件，

#12，lstrip 除去左邊空格

#13, rstrip 除去右邊空格

#14, center 居中，默認空格。

#15，count查找元素的個數，可以切片，若沒有返回0

#16，expandtabs 方法把字符串中的 tab 符號('\t')轉為空格，tab 符號('\t')默認的空格數是 8。

#17，tabsize -- 指定轉換字符串中的 tab 符號('\t')轉為空格的字符數。

# a= '\t\t\tegon\t\t\t'# a.expandtabs(tabsize=8) # egon

# print(a)

#18，replace(old，new,次數) 替換

#19，isdigit，判斷是否為數字組成 返回bool值

#20，isalpha, 判斷是否為字母組成 返回bool值

#21，isalnum 判斷是否為字符和字母組成 返回bool值

#12,swapcase 大小寫翻轉

#23，for i in可迭代對象。

#24，join：字符串拼接

#25，len()：求字符串，列表，數字長度

五，列表list(ret = [1,2,3,'abc',[1,2],(1,2,3)])-------可變類型(有序)

定義：變量的值放在【】里面，[ ]內以逗號分隔，按照索引，存放各種類型，每個位置代表一個元素

特性：1，可存放多個值???? 2，可修改指定索引為值對應的值????? 3，按照從左至右的順序定義列表元素，下標從0開始。

2，創建列表

list_test = ['1hf'，12，‘ok’]? 或?? list_test = list('abc')?? 或 list_test = list(['lhf'，12，‘ok’])

3，列表常用操作

索引--------切片------追加-------刪除------長度-------循環--------包含

增： append----追加??????? insert-------按索引增加???????? extend-------迭代添加

#；列表的增

#1.insert--按索引增加，

# li= [1,'a','b',2,3,'a']

# li.insert(1,'金鑫')

# li.insert(3,'馬德勝')

# print(li)

#2.append---追加，沒有返回值

# li= [1,'a','b',2,3,'a']

# li.append('太白金星') #增加到列表最后面

# li.append([1,3,5]) #append中只能跟一個類型，數字，字符串，列表，字典等

# print(li)

#3.extend--迭代添加,將被添加的類型中的每一個元素或字符一個一個添加，沒有返回值，默認跟到最后面

li= [1,'a','b',2,3,'a']

# li.extend('ABC')

# li.extend(['太白金星','金鑫'])

# li.extend({'k':'v','k1':'k2'})

# li.extend('w,r,c')

# print(li)

刪：pop------按索引刪，有返回值 remove-----按元素刪，沒有返回值 clear----清空列表，返回空列表 del----按索引和切片刪，可以刪除整個列表，沒有返回值

# 1.pop

# li= [1,'a',['a',10],{'k1':'v1'}]

# # a=li.pop() #pop如果不指定索引刪除，默認刪除最后一個元素

# a= li.pop(-1) #指定索引刪除

# print(li,a)

#2.remove

# li= [1,'a',['a',10],{'k1':'v1'}]

# # li.remove(1) #按元素刪

# # li.remove() #后不跟指定元素報錯

# print(li)

#3.del

# li= [1,'a',['a',10],{'k1':'v1'}]

# del li[2] #按索引刪

# del li[0:2] #按切片刪，顧頭不顧尾

# del li #刪除整個列表，不能輸出，沒有返回值

# print(li)

# #4.clear

# li= [1,'a',['a',10],{'k1':'v1'}]

# li.clear() #請空列表，

# print(li)

改：按索引或切片修改(按切片修改是迭代式修改)

# li[2] = '馬德勝' #按索引改

# li[2] = ['gsdfg',1,2]

#按切片修改

# li[0:2] = '臺標金鑫' #迭代修改

li[0:2] = ['太白','金鑫'] #迭代修改

print(li)

查：按索引，切片，循環查找

#查-----按切片，索引，循環查找

li= [1,'a',['a',10],{'k1':'v1'}]

#1,print(li[2]) #索引查

#2.print(li[0:3]) #切片查找時，顧頭不顧尾

#3.for i inli: #循環查找

# print(i)

其他操作：

1，count：計數，統計一個元素在列表中出現的次數

li = [1,2,3,2,8,2] #或字符串

a= li.count(2) #有返回值

print(a)

2，index：找某個元素在列表中位置的索引

li = ['a','b','c','d','e']

# a= li.index('b') # b的在列表中位置的索引為1

b= li.index('e') # e為4

# print(a)

print(b)

3，sort：對列表元素進行順序排序，沒有返回值.sort(revers )

# li = [1,2,3,2,8,2,4,9,10,6,7,5]

# li.sort() #[1, 2, 2, 2, 3, 4, 5, 6, 7, 8, 9, 10] 順序排序

# li.sort(reverse=False) #正序排序

# li.sort(reverse=True) # 倒序排序

# print(li)

# li= ['a','f','b','e','c','d']

# li.sort()

# print(li)

4，reverse：將列表中的元素反向存放(翻轉)

# i = [1,2,3,2,8,2,4,9,10,6,7,5]

# i.reverse() #翻轉(前后調換順序),可以與sort配合連用

# print(i) #[5, 7, 6, 10, 9, 4, 2, 8, 2, 3, 2, 1]

# li= ['a','b','c','d']

# li.reverse()

# print(li)

***重點：當循環列表時，如果在循環中刪除某個或者某些元素，列表元素個數改變，索引改變，容易出錯。

六，元組(tupe)---不可變類型，可存放任意類型的數據

1，定義：與列表類似，只不過【】改為()

2，特性：可存放多個值

3，不可變類型

4，按照從左至右的順序定義元組，下標從0開始順序訪問，有序

元祖創建：

ages = (11，12，33，45)或 ages = tuple((11,12，13,58))

元組常用操作：

索引-------切片--------循環------長度------包含

元組也是一種列表，也可以用切片，只不過取出來的值還是元組形式

l = (1,2,3,4,5,6)

print(l[0::2])

七，字典?? ---可變類型(字典的key是不可變類型)，無須，數據關聯性強，python中唯一的映射類型，以鍵值對(key--value)的形式存儲數據。字典的鍵必須是可哈希的。

字典時出列表意外python中最靈活的內置數據類型，列表是有序的對象結合，字典時無須的對象結合。

字典與列表之間的區別在于，當字典中的元素是通過鍵來存取的，而不是通過便宜存取的。

****注意：python中，不可變類型(數字，字符串，元組，)都是可哈希的，**字典的鍵也是可哈希的**而字典，列表本身則不是可哈希的，因為它們是可變類型。

6-1：增(兩種方式)

# 1方式一

dic1= {'name':'德勝','age':'18','sex':'男'}

# dic1['name'] = '金星'# print(dic1)

#當字典為空時，添加鍵值對，當字典中的鍵值存在時，鍵不變，值覆蓋，當字典中的鍵值不存在時，則添加鍵值對。

# 2方式二

# setdefault :在字典中添加鍵值對，如果只有鍵那對應的值用None代替，若原字典中存在設置的鍵值對，不會被更改和覆蓋

# dic1.setdefault('k','v')

# print(dic1)

# dic1.setdefault('k','v1')

dic1.setdefault('k') #鍵對應的值默認為None

print(dic1)

6-2：刪

#字典的刪除有四種方式

# 1pop根據鍵刪除值(根據key刪value),有返回值，如果要刪除的key不存在，報錯

dic1= {'name':'德勝','age':'18','sex':'男'}

# a = dic1.pop('name') #按鍵刪除值

# dic1.pop('德勝') #按值不能刪除鍵(報錯)

# dic1.pop('gdsfgs') #間不存在，則報錯

# print(a,dic1)

#方式二

# del 無返回值

# del dic1['name'] #根據鍵刪除值

# del dic1 #不能直接刪掉整個字典

# del dic1['gfhfghsdf'] #若鍵不存在時，刪除則報錯，

# print(dic1)

# 方式三

# popitem #隨機刪除字典的某個鍵值對，將刪除的鍵值對以元組的形式返回

# dic1.popitem()

# print(dic1)

#方式四

# clear 清空字典，返回一個空字典

dic1.clear()

print(dic1)

6-3 改

# 字典的改有兩種方式

#方式一

dic1= {'name':'德勝','age':'18','sex':'男'}

# dic1['name'] = '英雄'#根據鍵改值

# print(dic1)

#方式二

# update：用于兩個字典合并，原字典中有的鍵值對，鍵不變，值覆蓋。沒有的鍵值對添加到原字典中

dic2= {'name':'愛根','hobbie':'籃球'}

dic1.update(dic2) #沒有的添加，相同的覆蓋

print(dic1)

6-4 查

# 字典的查有兩種方式

dic1= {'name':'德勝','age':'18','sex':'男'}

# 方式一

# value= dic1['name'] #按鍵查值

# print(value)

# value1= dic1['dfsdds'] #沒有就會報錯

# print(value1)

# 方式二

# value= dic1.get('name') #根據鍵找對應的值

# print(value)

value1= dic1.get('fdgdfg') #若要查的值不存在，不報錯，默認返回None

print(value1)

6-5? 字典的其他操作

#字典其他操作

dic1= {'name':'德勝','age':'18','sex':'男'}

# #1---items

# item=dic1.items() #這個類型就是dict_items類型，可迭代的

# print(item) #dict_items([('name', '德勝'), ('age', '18'), ('sex', '男')])

#2---keys #或取所有的鍵

# key=dic1.keys()

# print(key) #dict_keys類型

#3---values 3獲取所有的值

valur=dic1.values()

print(valur) # dict_values類型

6-6? 字典的循環

dic1 = {'name':'德勝','age':'18','sex':'男'}

#1，

#for key indic1: #獲取所有的鍵(key)

# print(key)

#for key indic1.keys(): #獲取所有的key

# print(key)

#2，

#for value indic1.values(): #獲取所有的值(value)

# print(value)

#3，

#for item indic1.items(): #以元組的形式獲取元素

# print(item)

#4，

#for key,value indic1.items(): #獲取元組

# print(key,value)

for ------循環

for循環：用戶按順序循環可迭代對象的內容

# msg= '老男孩python是全國范圍內最好的python培訓機構'#for item inmsg: #循環遍歷字符串的每一個元素

# print(item)

# li= ['alex','銀角','女神','愛根','太白']

#for i inli: #遍歷列表的每一個元素

# print(i)

# dic= {'name':'太白','age':18,'sex':'man'}

#for k,y indic.items():

# print(k,y)

enumerate----枚舉

# enumerate----枚舉 (同時可以獲得索引和值)

li= ['alex','銀角','女神','愛根','太白']

#for i inenumerate(li): 索引默認從0開始

# print(i)

#for index,name in enumerate(li,1): #可以設置索引起始值

# print(index,name)for index,name in enumerate(li,100):

print(index,name)

range：指定范圍，生成指定數字

#range :指定范圍，生成指定數字

#for i in range(1,10): #取1-10之間的數

# print(i)

#for i in range(1,10,2): #取1-10之間的數(有步長)

# print(i)for i in range(10,1,-2): #反向步長

print(i)

1.可變量類型與不可變類型-----------?可變的水類型：指的是在ID不變的情況下，數據類型內部元素value可變

注意：在python基本數據類型中：可變類型有：字典(dict’)和列表(list)，不可變類型有：數字(int/float)，字符串(str)，元組(tuple)和集合(set)

定義一個數字類型??? num=10

定義一個類型的三個特征：? id? 、 type(類型)? ，?? value? (從變量名獲取)

-------列表---可變類型---可存多個值，主看元素，每一個元素都可以改都可以存

--------字典---不能出現重復的key，key跟一個值唯一映射

---------不可變的數據類型：value改變，id也跟著改變

如：數字---------整體存整體改

浮點型：

字符串-----修改也是開辟了新的內存空間--------不可變類型------整體存整體改

-----布爾---True對應1??????? false對應0

-----------運算符(+加、-減、*乘、/除)-------------算數運算符

//：地板除---------取整????? %-----取余/取模??????? **-------次方

字符串------可以用+與*

列表--------用+ ，*(只能加乘)

以上兩種類型都可以拼接。。。。。。

字典--------不能+，-，*，/

比較運算符------數字

num1=3????????? num2=1

>,=,<=,==,!=

==判斷的是值

is判斷的是id

字符串比較----字符串的比較是按照字符的位置依次比較

列表---------只能在同種類型的數據情況下比較

------------ 邏輯與and

age=input(“你芳齡幾何：”)

sex=input("你的性別是：")

age=int(age)

res1=age>50

res2=sex=='female'

res3=res1 and res2

print(res3)

------------邏輯或 or----成立一個條件就行

-------not true==false

------not false==true

------------------運算符優先級：自上而下，優先級從高到低

or x為真值為x，x為假，值為y

print(4 or 3)

print(2 or 3)

print(1 or 3)

print(0 or 3)

print(-1 or 3)

print(0 and 3 or 4 or 1 or 2)

print(3 or 3 > 2)

print(3>2 or 3)

and,x為真值為y，x為假，值為x

print(4 and 3)

print(2 and 3)

print(1 and 3)

print(0 and 3)

print(-1 and 3)

邏輯and 和 or

邏輯運算符：(優先級)

優先級：()>not>and>or

同等優先級條件下，從左至右一次計算

print(4 > 3 or 4 < 3 and 1 != 1) 結果為True

print(2 > 1 and 3 <4 or 4 > 5 and 2 < 1) 結果為False

print(1 > 2 and 3 < 4 or 4 > 5 and 2 > 1 or 9 < 8) 結果為Flase

print(1 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6) 結果為False

print(not2 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6) 結果為False'or'：x or y 如果x為真，則值為x，否則值為y

print(4 or 3) 真(True)----4print(2 or 3) 真(True)----2print(1 or 3) 真(True)----1print(0 or 3) 假(False)---3print(-1 or 3) 真(True)---- -1

'and'：x and y 如果x為真，則值為y，否則為x

print(4 and 3) True----3print(2 and 3) True----3print(1 and 2) True----2print(0 and 3) False----0print(-1 and 3) True----3

int與 bool值之間的轉換1，bool轉換為int

a= int(True)

b= int(False)

print(a,b)2,int轉換為bool

a= bool(413456)

b= bool(6.5)

c= bool(0)

d= bool(-1)

print(a,b,c,d) True,True,False,Trueint(包含) not in(不包含)

s1= 'abcd'print('a' insl) True

print(1 and 'a' ints1) True

print('ag' ins1) False

print('ad' not in s1) True

邏輯運算示例

八，集合---------------?無序不重復的數據集合，集合里面的元素是可哈希的(集合本身是不可哈希的)(去重)：可以包含多個元素，用逗號分隔，

集合的三個原則：

1.每個元素都必須是不可變類型?????????????????????????????????????????????????????????????????? **可變類型是不可hash類型

2.沒有重復的元素(去重)?????????????????????????????????????????????????????????????????????????? **不可變類型是可hash類型

3.輸出/運行的結果是無須的

定義：形如-------a={'alex','egon','wupeiqi'}

符號：{? }------------set? 無須，元素關系

set-------集合是可變類型，中的元素是不可變類型

1，集合的創建

set1 = set({1,2,'barry'})

set12={1,2,'barry'}

print(set1,type(set1),set12,type(set12))

2，集合的增

# add---增加，添加

set1= {'alex','wusir','ritian','egon','barry'}

# set1.add('金鑫') # 集合是不可變類型，所以，列表和字典不能添加

# print(set1)

linuex={'wupeiqi','egon','gangdan'}

linuex.add('馬德勝') #add-----添加 set類型中的集合是可變類型

print(linuex)

#linuex.add(1,2,3) # 報錯----------只能添加不可變類型

print(linuex)

# update 迭代添加 # set1.update('a') # print(set1) # # set1.update('金鑫是太白金星')

# print(set1) #{'alex', '鑫', 'wusir', '金', 'barry', '白', 'ritian', '星', 'egon', '是', '太'}

3，集合的刪

set1 = {'alex','wusir','ritian','egon','barry'}

# set1.remove('alex') #根據元素刪

# print(set1)

# set1.pop() #隨機刪除一個元素，有返回值

# print(set1)

# set1.clear() #清空集合 返回set()

# print(set1)

del set1 #直接刪除集合，不留任何痕跡

# print(set1)

-------------discard--------------

linuex={'wupeiqi','egon','gangdan'}

linuex.discard('wupeiqi') discard-----指定刪除的元素--元素不存在報錯

print(linuex)

4，集合是不可變類型，不能改(孫子，兒子均不能改)

5，集合的查

set1 = {'alex','wusir','ritian','egon','barry'}for i in set1: #for循環查集合的所有元素

print(i)

###求兩者的共同部分：求即報名python又報名linuex的學生姓名

a={'ab','cd','ef','g','h'}

b={'cd','h','abcd'}

l=[]for c ina:if c inb:

l.append(c)print(l)

求只報a沒有報b的同學

a={'ab','cd','ef','g','h'}

b={'cd','h','abcd'}

l=[]for c ina:if c not inb:

l.append (c)print(l)

in(包含，在)?? 和??? not? in(不包含，不在)

python={'alse','egon','yuanhao','wupeiqi','gangdan','biubiu'}print('egon' inpython)print ('alex' and 'biubiu' inpython)print('馬德勝'not inpython)print('yuanhao' not in python)

并集(l)：老男孩所有報名學生的名字集合????? -----? |? -----并集，合并 或 ?union

python={'alex','egon','yuanhao','馬德勝','123'}

linuex={'馬德勝','biubiu','123'}

s=python |linuexprint(s)

a={1,2,3}

b={1,3,5,8,9}

c=b |aprint(c)

交集 -------&或intersection

h1={'a','b','c'}

h2={1,'b',2,'a',3,'c'}

s=h1 &h2print(s)

差集-------- - ---difference

l={1,2,3,4,5}

x={2,3}

b= l-xprint(b)

對稱差集------ ^ ---沒有同時報python和linuex的學生姓名 ?symmetric_difference

python={'alex','egon','yuanhao','馬德勝',123}

linuex={'馬德勝','biubiu',123,456}#print(python ^ linuex)

a=python ^linuexprint(a)

父集----->=

a={1,2,3,4}

b={2,3}print(a>=b)----Trueprint(b>=a)----False

子集--------<=

a={'a','b','c'}

b={'a','b','c','d'}print(a<=b

深淺拷貝(copy)

1，淺copy

賦值運算

# l1= [1,2,3,['barry','alex']]

# l2=l1

# # l1[0] = 111# l1[3][0] = 'egon'# print(l1)

# print(l2)

#淺拷貝: 第一層創建的是獨立的內存地址，在嵌套的層級內(不管是嵌套多少層)，則執行的是同一個內存空間

# l1= [1,2,3,['barry',['kv'],'alex']]

# l2=l1.copy()

# # print(l1,id(l1))

# # print(l2,id(l2))

#

# # l1[1] = 222# # l1[3][1]='123'# l1[3][1][0] = '金鑫'# print(l1,id(l1))

# print(l2,id(l2))

2，深deepcopy

#深拷貝deepcopy ------怎么樣(深)都是獨自的內存空間，改變不了

import copy

l1= [1,2,3,['barry',[1,'小雞',{'k1':'k2','k2':'k3'}],'金星']]

l2=copy.deepcopy(l1)

# l1[1] = 222各自獨立的內存空間

# l1[3][2] = '馬德勝'# l1[3][1][1] = 'haha'l1[3][1][2]['k1'] = '深淺'print(l1,type(l1))

print(l2,type(l2))

基本數據類型之間的所有轉換

int??與?Str:

int---> str：str(int)?? 條件：字符串必須是數字類型

str----->int ： int(str) 條件：數字必須是字符串類型

int 與 bool：

int ----->bool：除了0之外，全都是True

bool------->int ：1是True????? 0是False

int 與 list：之間不存在互相轉換，若要將數字變成列表，必須迭代添加才行

str 與 bool：

str----->bool：bool(str) 除了空字符串，其余的都是True

bool----->str：str(bool)

str 與 list：

str------->list：split(將字符串切割)

list-------->str：join(拼接)

tuple 與 list：

tuple----------->list：list(tuple)

list ------------>tuple：tuple(list)

str 與 tuple：

str----------->tuple：tuple(str)

dict 與 list：

str，list ------------>dict：formkeys

dict------------>list：keys，values，items

*******************

數字，字符串，列表，元祖，字典對應的布爾值的False 分別是什么？(5分)

# 數字對應的布爾值False的是：0# 字符串對應的布爾值為False的是：' '空字符串

# 列表對應的布爾值為False的是： [ ] 空列表

# 元組對應的布爾值為False的是：()空元組

# 字典對應的布爾值為False的是： { }空字典

總結

以上是生活随笔為你收集整理的python基本数_python--基本数据类型的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。