LP890127
LP890127

Python3 与 C# 基础语法对比（List、Tuple、Dict、Set专栏）

 

Code：https://github.com/lotapp/BaseCode

多图旧版：https://www.cnblogs.com/dunitian/p/9156097.html

在线预览：http://github.lesschina.com/python/base/pop/3.list_tuple_dict_set.html

今天说说List、Tuple、Dict、Set。POP部分还有一些如Func、IO（也可以放OOP部分说）然后就说说面向对象吧。

先吐槽一下：Python面向对象真心需要规范，不然太容易走火入魔了 -_-!!! 汗，下次再说。。。

1.Python列表相关¶

1.1.列表定义、遍历¶

info_list=[] #空列表

infos_list=["C#","JavaScript"]

遍历和之前一样，for 或者 while 都可以

for扩展：https://www.cnblogs.com/dunitian/p/9103673.html#forelse

In [1]: 
# 定义一个列表，列表虽然可以存不同类型，一般我们把相同类型的值存列表里面
infos_list=["C#","JavaScript"]#定一个空列表 list=[]
In [2]: 
# for遍历
for item in infos_list:
    print(item)
  
C#
JavaScript
In [3]: 
# while遍历
i=0
while i<len(infos_list):
    print(infos_list[i])
    i+=1
  
C#
JavaScript
 

1.2.列表添加¶

末尾追加 infos_list.append("Java")

In [4]: 
# 添加~末尾追加
infos_list.append("Java")
print(infos_list)
  
['C#', 'JavaScript', 'Java']
 

指定位置插入 infos_list.insert(0,"Python")

插入列表 infos_list.insert(0,temp_list)

Python在指定位置插入列表是真的插入一个列表进去，C#是把里面的元素挨个插入进去

看后面的列表嵌套，是通过下标方式获取，eg: infos_list[0][1]

In [5]: 
# 添加～指定位置插入
infos_list.insert(0,"Python")
print(infos_list)

# 列表嵌套（后面会有扩展）
temp_list=["test1","test2"]
infos_list.insert(0,temp_list)
print(infos_list)
  
['Python', 'C#', 'JavaScript', 'Java']
[['test1', 'test2'], 'Python', 'C#', 'JavaScript', 'Java']
In [6]: 
infos_list #查看下现在列表是什么
Out[6]: 
[['test1', 'test2'], 'Python', 'C#', 'JavaScript', 'Java']
 

如果你想像C#那样把里面的元素挨个插入进去，可以用extend()

添加一个列表 infos_list.extend(infos_list2)

In [7]: 
# 添加一个列表
infos_list2=["张三",21]#python里面的列表类似于List
infos_list.extend(infos_list2)
print(infos_list)
 
        
       
      
     
    
 
     
 
      
 
       

           
       
 
       
 
        
[['test1', 'test2'], 'Python', 'C#', 'JavaScript', 'Java', '张三', 21]

 
       
 
      
 
     
 
    
 
    
   
 
    
 
     

       In [8]: 
     
 
     
 
      
 
       
 
        
#可以查看extend方法描述
help(infos_list.extend)

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
Help on built-in function extend:

extend(...) method of builtins.list instance
    L.extend(iterable) -> None -- extend list by appending elements from the iterable


 
       
 
      
 
     
 
    
 
   
 
   
 
    

        
    
 
    
 
     
 
      
1.3.列表删除¶
 
      
infos_list.pop() # 删除最后一个
 
      
infos_list.pop(0) # 删除指定索引，不存在就报错
 
     
 
    
 
   
 
   
 
    
 
     

       In [9]: 
     
 
     
 
      
 
       
 
        
# 删除
# pop()删除最后一个元素，返回删掉的元素
infos_list.pop()

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

         Out[9]: 
       
 
       
 
        
21
 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [10]: 
     
 
     
 
      
 
       
 
        
infos_list #查看一下列表

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

         Out[10]: 
       
 
       
 
        
[['test1', 'test2'], 'Python', 'C#', 'JavaScript', 'Java', '张三']
 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [11]: 
     
 
     
 
      
 
       
 
        
# 删除
# pop(index) 删除指定下标元素，返回删掉的元素
infos_list.pop(0)

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

         Out[11]: 
       
 
       
 
        
['test1', 'test2']
 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [12]: 
     
 
     
 
      
 
       
 
        
infos_list #查看一下列表

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

         Out[12]: 
       
 
       
 
        
['Python', 'C#', 'JavaScript', 'Java', '张三']
 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [13]: 
     
 
     
 
      
 
       
 
        
# 索引不存在就报错
infos_list.pop(10)

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
 in ()
      1 # 索引不存在就报错
----> 2infos_list.pop(10)

IndexError: pop index out of range
 
       
 
      
 
     
 
    
 
   
 
   
 
    

        
    
 
    
 
     
 
      
infos_list.remove("张三") # remove("")删除指定元素，不存在就报错
 
      
del infos_list[1] # 删除指定下标元素，不存在就报错
 
      
del infos_list # 删除集合（集合再访问就不存在了）不同于C#给集合赋null
 
      
关于del的删除后面还会说，这个和linux里面的ln引用删除类似
 
     
 
    
 
   
 
   
 
    
 
     

       In [14]: 
     
 
     
 
      
 
       
 
        
# remove("")删除指定元素
infos_list.remove("张三") #没有返回值
print(infos_list)

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
['Python', 'C#', 'JavaScript', 'Java']

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [15]: 
     
 
     
 
      
 
       
 
        
infos_list.remove("dnt") # 不存在就报错

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
 in ()
----> 1infos_list.remove("dnt") # 不存在就报错

ValueError: list.remove(x): x not in list
 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [16]: 
     
 
     
 
      
 
       
 
        
# del xxx[index] 删除指定下标元素
del infos_list[1] #没有返回值
print(infos_list)

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
['Python', 'JavaScript', 'Java']

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [17]: 
     
 
     
 
      
 
       
 
        
del infos_list[10] #不存在就报错

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
 in ()
----> 1del infos_list[10] #不存在就报错

IndexError: list assignment index out of range
 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [18]: 
     
 
     
 
      
 
       
 
        
del infos_list # 删除集合（集合再访问就不存在了）

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [19]: 
     
 
     
 
      
 
       
 
        
infos_list # 集合再访问就不存在了

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
 in ()
----> 1infos_list # 集合再访问就不存在了

NameError: name 'infos_list' is not defined
 
       
 
      
 
     
 
    
 
   
 
   
 
    

        
    
 
    
 
     
 
      
1.4.列表修改¶
 
      
Python修改：（只能通过索引修改）
 
      
infos_list2[1]="PHP" # 只有下标修改一种方式，不存在则异常
 
      
想按值修改需要先查下标再修改 eg:
 
      
infos_list2.index("张三")
 
      
infos_list2[0]="GO"
 
      
infos_list2.index("dnt") # 不存在则异常
 
     
 
    
 
   
 
   
 
    
 
     

       In [20]: 
     
 
     
 
      
 
       
 
        
# 修改 xxx[index]=xx
# 注意：一般不推荐在for循环里面修改
infos_list2 #查看list2列表

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

         Out[20]: 
       
 
       
 
        
['张三', 21]
 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [21]: 
     
 
     
 
      
 
       
 
        
infos_list2[1]="PHP" #只有下标修改一种方式
print(infos_list2)

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
['张三', 'PHP']

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [22]: 
     
 
     
 
      
 
       
 
        
infos_list2[3]="GO" #不存在则异常

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
 in ()
----> 1infos_list2[3]="GO" #不存在则异常

IndexError: list assignment index out of range
 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [23]: 
     
 
     
 
      
 
       
 
        
# 想按值修改需要先查下标再修改
infos_list2.index("张三")
infos_list2[0]="GO"
print(infos_list2)

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
['GO', 'PHP']

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [24]: 
     
 
     
 
      
 
       
 
        
infos_list2.index("dnt")#不存在则异常

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
 in ()
----> 1infos_list2.index("dnt")#不存在则异常

ValueError: 'dnt' is not in list
 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [25]: 
     
 
     
 
      
 
       
 
        
# 知识面拓展： https://www.zhihu.com/question/49098374
# 为什么python中不建议在for循环中修改列表？
# 由于在遍历的过程中，删除了其中一个元素，导致后面的元素整体前移，导致有个元素成了漏网之鱼。
# 同样的，在遍历过程中，使用插入操作，也会导致类似的错误。这也就是问题里说的无法“跟踪”元素。
# 如果使用while，则可以在面对这样情况的时候灵活应对。

 
       
 
      
 
     
 
    
 
   
 
   
 
    

        
    
 
    
 
     
 
      
1.5.查询系列¶
 
      
in, not in, index, count
 
     
 
    
 
   
 
   
 
    
 
     

       In [26]: 
     
 
     
 
      
 
       
 
        
# 查询 in, not in, index, count
names_list=["张三","李四","王二麻子"]

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [27]: 
     
 
     
 
      
 
       
 
        
# 张三在列表中执行操作
if "张三" in names_list:
    names_list.remove("张三")
print(names_list)

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
['李四', '王二麻子']

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [28]: 
     
 
     
 
      
 
       
 
        
# 查看"大舅子"不在列表中执行操作
if "大舅子" not in names_list:
    names_list.append("大舅子")
print(names_list)

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
['李四', '王二麻子', '大舅子']

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [29]: 
     
 
     
 
      
 
       
 
        
# 查询王二麻子的索引
print(names_list.index("王二麻子"))

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
1

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [30]: 
     
 
     
 
      
 
       
 
        
# 统计
print(names_list.count("大舅子")) 
print(names_list.count("逆天")) 

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
1
0

 
       
 
      
 
     
 
    
 
   
 
   
 
    

        
    
 
    
 
     
 
      
1.6.排序系列¶
 
      
num_list.reverse()# 倒序
 
      
num_list.sort() # 从小到大排序
 
      
num_list.sort(reverse=True) # 从大到小
 
     
 
    
 
   
 
   
 
    
 
     

       In [31]: 
     
 
     
 
      
 
       
 
        
# 排序专用
num_list=[1,3,5,88,7]

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [32]: 
     
 
     
 
      
 
       
 
        
# 倒序 reverse 逆置
num_list.reverse()
print(num_list)

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
[7, 88, 5, 3, 1]

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [33]: 
     
 
     
 
      
 
       
 
        
# 从小到大排序
num_list.sort()
print(num_list)

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
[1, 3, 5, 7, 88]

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [34]: 
     
 
     
 
      
 
       
 
        
# 从大到小
num_list.sort(reverse=True)
print(num_list)

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
[88, 7, 5, 3, 1]

 
       
 
      
 
     
 
    
 
   
 
   
 
    

        
    
 
    
 
     
 
      
1.7.列表切片¶
 
      
列表的切片操作很有用，主要跟数据相关，实际应用中和dict（后面会讲）联合使用
 
      
python切片语法：[start_index:end_index:step] （end_index取不到）
 
      
先说说 range
 
     
 
    
 
   
 
   
 
    
 
     

       In [35]: 
     
 
     
 
      
 
       
 
        
# range扩展～创建一个整数列表
# range(5)生成的序列是从0开始小于5的整数～[0,5)
range_list=list(range(5))
print(range_list)

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
[0, 1, 2, 3, 4]

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [36]: 
     
 
     
 
      
 
       
 
        
# range(1,5)生成的序列是从1开始小于5的整数～[1,5)
range_list=list(range(1,5))
print(range_list)

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
[1, 2, 3, 4]

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [37]: 
     
 
     
 
      
 
       
 
        
# 列表的切片操作很有用，主要跟数据相关，实际应用中和dict（后面会讲）联合使用
# python切片语法：[start_index:end_index:step] （end_index取不到）
top100=list(range(1,101)) #[1,101) => 1~100
print(top100)

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [38]: 
     
 
     
 
      
 
       
 
        
# 取前10个元素
top100[:10] #等价于：top100[0:10]

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

         Out[38]: 
       
 
       
 
        
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [39]: 
     
 
     
 
      
 
       
 
        
# 取最后10个元素
top100[-10:]

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

         Out[39]: 
       
 
       
 
        
[91, 92, 93, 94, 95, 96, 97, 98, 99, 100]
 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [40]: 
     
 
     
 
      
 
       
 
        
# 前11~20（eg：第二页）
top100[10:20]

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

         Out[40]: 
       
 
       
 
        
[11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [41]: 
     
 
     
 
      
 
       
 
        
# 取80~90（eg:倒数第二页）
top100[-20:-10]

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

         Out[41]: 
       
 
       
 
        
[81, 82, 83, 84, 85, 86, 87, 88, 89, 90]
 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [42]: 
     
 
     
 
      
 
       
 
        
# 前20个数，每两个取一个（eg:隔行换样式）
top100[:20:2]

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

         Out[42]: 
       
 
       
 
        
[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [43]: 
     
 
     
 
      
 
       
 
        
# 所有数每10个取一个（eg:test的时候十里挑一）
top100[::10]

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

         Out[43]: 
       
 
       
 
        
[1, 11, 21, 31, 41, 51, 61, 71, 81, 91]
 
       
 
      
 
     
 
    
 
   
 
   
 
    

        
    
 
    
 
     
 
      
1.8.Python列表相关的扩展¶
 
      
列表虽然可以存不同类型，一般我们把相同类型的值存列表里面，不同类型存字典里（key，value）
 
      
列表嵌套，获取用下标的方式：num_list[5][1]
 
     
 
    
 
   
 
   
 
    
 
     

       In [44]: 
     
 
     
 
      
 
       
 
        
# #列表嵌套(列表也是可以嵌套的)
num_list2=[33,44,22]
num_list.append(num_list2)
print(num_list)

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
[88, 7, 5, 3, 1, [33, 44, 22]]

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [45]: 
     
 
     
 
      
 
       
 
        
# 输出
print(num_list[5])
print(num_list[5][1]) #嵌套列表获取值的方式

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
[33, 44, 22]
44

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [46]: 
     
 
     
 
      
 
       
 
        
# 引入Null==>None
a=[1,2,3,4]
b=[5,6]
a=a.append(b)#a.append(b)没有返回值
print(a)#None

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
None

 
       
 
      
 
     
 
    
 
   
 
   
 
    

        
    
 
    
 
     
 
      
补充概念，str 和 tuple 也可以用切片操作哦～
 
      
str上次说了，这次说下Tuple（后面会继续说Tuple，先了解下吧）
 
     
 
    
 
   
 
   
 
    
 
     

       In [47]: 
     
 
     
 
      
 
       
 
        
# 取前两个 返回元组
(1,2,3,4,5)[:2]

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

         Out[47]: 
       
 
       
 
        
(1, 2)
 
       
 
      
 
     
 
    
 
   
 
   
 
    

        
    
 
    
 
     
 
      
1.9.列表生成式¶
 
      
列表生成式是Python内置用来 创建list的生成式
 
      
eg：要生成 list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
 
      
传统方法是通过循环来实现，比如：
 
     
 
    
 
   
 
   
 
    
 
     

       In [48]: 
     
 
     
 
      
 
       
 
        
i=1
my_list=[]
while(i<11):
    my_list.append(i)
    i+=1

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [49]: 
     
 
     
 
      
 
       
 
        
my_list

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

         Out[49]: 
       
 
       
 
        
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
 
       
 
      
 
     
 
    
 
   
 
   
 
    

        
    
 
    
 
     
 
      
有了列表生成式就方便了 list(range(1, 11))（之前说列表切片的时候稍微引入了一下range）
 
      
另一种写法：[x for x in range(1,11)] 来看看案例：
 
     
 
    
 
   
 
   
 
    
 
     

       In [50]: 
     
 
     
 
      
 
       
 
        
list(range(1, 11))

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

         Out[50]: 
       
 
       
 
        
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [51]: 
     
 
     
 
      
 
       
 
        
[x for x in range(1,11)]

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

         Out[51]: 
       
 
       
 
        
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
 
       
 
      
 
     
 
    
 
   
 
   
 
    

        
    
 
    
 
     
 
      
可能有人会问，第一种写法不是挺好的嘛，为什么要用第二种复杂写法？
 
      
看看下面案例你就知道它的强大了（能简写就简单）
 
      
现在有了range生成就更方便了，可如果我们需要 1~10的平方列表呢？`[1^2,2^2,....10^2]'
 
     
 
    
 
   
 
   
 
    
 
     

       In [52]: 
     
 
     
 
      
 
       
 
        
my_list=[]
for i in range(1,11):
    my_list.append(i*i)
    i+=1
print(my_list)

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

 
       
 
      
 
     
 
    
 
   
 
   
 
    

        
    
 
    
 
     
 
      
但是循环太繁琐，而列表生成式则可以用一行语句代替循环生成上面的list
 
      
[x * x for x in range(1, 11)] 你可以这样理解==>就是我们平时的for循环嘛，前面的参数是返回值罢了
 
     
 
    
 
   
 
   
 
    
 
     

       In [53]: 
     
 
     
 
      
 
       
 
        
[x*x for x in range(1,11)]

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

         Out[53]: 
       
 
       
 
        
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [54]: 
     
 
     
 
      
 
       
 
        
# 把一个list中所有的字符串变成小写
my_list = ['Hello', 'World', 'I', 'Love', 'You']

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [55]: 
     
 
     
 
      
 
       
 
        
[x.lower() for x in my_list]

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

         Out[55]: 
       
 
       
 
        
['hello', 'world', 'i', 'love', 'you']
 
       
 
      
 
     
 
    
 
   
 
   
 
    

        
    
 
    
 
     
 
      
列表生成式的强大仅限于此嘛？No～
 
      
for循环后面还可以加上if判断 [x for x in range(1, 11) if x % 2 == 0]
 
      
多重for循环嵌套 [x + y for x in 'ABC' for y in 'AB']
 
     
 
    
 
   
 
   
 
    
 
     

       In [56]: 
     
 
     
 
      
 
       
 
        
# 1~10之间的偶数
[x for x in range(1, 11) if x % 2 == 0]

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

         Out[56]: 
       
 
       
 
        
[2, 4, 6, 8, 10]
 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [57]: 
     
 
     
 
      
 
       
 
        
# 数学里面的全排列
[x + y for x in 'ABC' for y in 'AB']

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

         Out[57]: 
       
 
       
 
        
['AA', 'AB', 'BA', 'BB', 'CA', 'CB']
 
       
 
      
 
     
 
    
 
   
 
   
 
    

        
    
 
    
 
     
 
      
其实你可以把他看成
 
      
 
       
list1=[]
for x in range(1,5):
    for y in range(1,4):
        list1.append((x,y))

 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [58]: 
     
 
     
 
      
 
       
 
        
# 数学里面的坐标轴（元组马上就讲了，你可以看看）
[(x,y) for x in range(1,5) for y in range(1,4)]

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

         Out[58]: 
       
 
       
 
        
[(1, 1),
 (1, 2),
 (1, 3),
 (2, 1),
 (2, 2),
 (2, 3),
 (3, 1),
 (3, 2),
 (3, 3),
 (4, 1),
 (4, 2),
 (4, 3)]
 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [59]: 
     
 
     
 
      
 
       
 
        
# (x,y,z)
[(x,y,z) for x in range(1,5) for y in range(1,4) for z in range(1,3)]

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

         Out[59]: 
       
 
       
 
        
[(1, 1, 1),
 (1, 1, 2),
 (1, 2, 1),
 (1, 2, 2),
 (1, 3, 1),
 (1, 3, 2),
 (2, 1, 1),
 (2, 1, 2),
 (2, 2, 1),
 (2, 2, 2),
 (2, 3, 1),
 (2, 3, 2),
 (3, 1, 1),
 (3, 1, 2),
 (3, 2, 1),
 (3, 2, 2),
 (3, 3, 1),
 (3, 3, 2),
 (4, 1, 1),
 (4, 1, 2),
 (4, 2, 1),
 (4, 2, 2),
 (4, 3, 1),
 (4, 3, 2)]
 
       
 
      
 
     
 
    
 
   
 
   
 
    

        
    
 
    
 
     
 
      
2.CSharp列表相关¶
 
      
2.1.列表定义、遍历¶
 
      
var infos_list = new List() { "C#", "JavaScript" };
 
      
遍历可以用foreach，for，while
 
      
     
    
   
 
    
 
     

       In [60]: 
     
 
     
 
      
 
       
 
        
%%script csharp
//# 定义一个列表
// # infos_list=["C#","JavaScript"]#[]
var infos_list = new List() { "C#", "JavaScript" };
// // # ###########################################################
// // # # 遍历 for while
// // # for item in infos_list:
// // #     print(item)
foreach (var item in infos_list)
{
    System.Console.WriteLine(item);
}
for (int i = 0; i < infos_list.Count; i++)
{
    System.Console.WriteLine(infos_list[i]);
}
// # i=0
// # while i 
        
       
      
     
    
 
     
 
      
 
       

           
       
 
       
 
        
C#
JavaScript
C#
JavaScript
C#
JavaScript

 
       
 
      
 
     
 
    
 
    
   
 
    

        
    
 
    
 
     
 
      
2.2.列表添加¶
 
      
Add，AddRange，Insert，InsertRange (和Python插入列表有些区别)
 
      
为了后面演示的方便，我这边定义一个自定义输出：
 
      
 
       
private static void DivPrintList(List<object> list, string say = "")
{
    Console.WriteLine($"\n{say}");
    foreach (var item in list)
    {
        System.Console.Write($"{item} ");
    }
}

 
      
 
      
添加系列Code：
 
      
 
       
var infos_list2 = new List<object>() { "张三", 21 };

// # # 增加
// # # 末尾追加
// # infos_list.append("Java")
infos_list.Add("Java");
DivPrintList(infos_list);

// # # 指定位置插入
// # infos_list.insert(0,"Python")
// # print(infos_list)
infos_list.Insert(0,"Python");
DivPrintList(infos_list);

// # # 添加一个列表
// # infos_list2=["张三",21]#python里面的列表类似于List            
// # infos_list.extend(infos_list2)
// # print(infos_list)
infos_list.AddRange(infos_list2);
DivPrintList(infos_list);

/*C#有insertRange方法 */
DivPrintList(infos_list2,"List2原来的列表：");
infos_list2.InsertRange(0,infos_list);
DivPrintList(infos_list2,"List2变化后列表：");
 
       
      
结果：
 
      
# 末尾追加
C# JavaScript Java 

# 指定位置插入
Python C# JavaScript Java 

# 添加一个列表
Python C# JavaScript Java 张三 21 

# insertRange方法
List2原来的列表：
张三 21 
List2变化后列表：
Python C# JavaScript Java 张三 21 张三 21
 
      
     
    
   
 
    

        
    
 
    
 
     
 
      
2.3.列表删除¶
 
      
移除指定索引：infos_list.RemoveAt(1);
 
      
移除指定值： infos_list.Remove(item);
 
      
清空列表： infos_list.Clear();
 
      
 
       
infos_list.RemoveAt(1);
// infos_list.RemoveAt(10);//不存在则报错
// infos_list.RemoveRange(0,1); //可以移除多个
DivPrintList(infos_list);
infos_list.Remove("我家在东北吗？"); //移除指定item，不存在不会报错
DivPrintList(infos_list,"清空前：");
infos_list.Clear();//清空列表
DivPrintList(infos_list,"清空后：");

 
      
 
      
输出：
 
      
Python JavaScript Java 张三 21 
清空前：
Python JavaScript Java 张三 21 
清空后：
 
     
 
    
 
   
 
   
 
    

        
    
 
    
 
     
 
      
2.4.列表修改¶
 
      
基本上和Python一样
 
      
 
       
DivPrintList(infos_list2);
infos_list2[1] = "PHP";
// infos_list2[3]="GO"; //不存在则异常
DivPrintList(infos_list2);
// # # 想按值修改需要先查下标再修改
// # infos_list2.index("张三")
// # infos_list2[0]="GO"
// # print(infos_list2)
// # # infos_list2.index("dnt")#不存在则异常
int index = infos_list2.IndexOf("张三");
infos_list2[index] = "GO";
DivPrintList(infos_list2);
infos_list2.IndexOf("dnt");//不存在返回-1

 
      
 
      
输出：
 
      
Python C# JavaScript Java 张三 21 张三 21 
Python PHP JavaScript Java 张三 21 张三 21 
Python PHP JavaScript Java GO 21 张三 21
 
      
2.5.列表查询¶
 
      
IndexOf，Count 这两个讲过了
 
      
查找用Contains，其他的用法你可以先看看
 
      
// # 查询 in, not in, index, count
// # names_list=["张三","李四","王二麻子"]
var names_list=new List(){"张三","李四","王二麻子"};
// Console.WriteLine(names_list.Find(i=>i=="张三"));
// Console.WriteLine(names_list.FirstOrDefault(i=>i=="张三"));
Console.WriteLine(names_list.Exists(i=>i=="张三"));
Console.WriteLine(names_list.Contains("张三"));
 
      
结果：
 
      
True
True
 
     
 
    
 
   
 
   
 
    

        
    
 
    
 
     
 
      
2.6.列表排序¶
 
      
 
       
// # # 排序(sort, reverse 逆置)
// # num_list=[1,3,5,88,7]
var num_list = new List<object>() { 1, 3, 5, 88, 7 };

// # #倒序
// # num_list.reverse()
// # print(num_list)
num_list.Reverse();
DivPrintList(num_list);
// # # 从小到大排序
// # num_list.sort()
// # print(num_list)
num_list.Sort();
DivPrintList(num_list);

// # # 从大到小
// # num_list.sort(reverse=True)
// # print(num_list)
num_list.Sort();
num_list.Reverse();
DivPrintList(num_list);

 
      
 
      
输出：
 
      
7 88 5 3 1 
1 3 5 7 88 
88 7 5 3 1
 
      
 
      
2.7.列表嵌套和多维数组的扩展¶
 
      
列表嵌套不能像python那样 下标操作，你可以继续循环遍历，或者可以定义多维数组来支持 num_list2[i][j]
 
      
定义：var num_list2 = new List() { 33, 44, 22,new List(){11,55,77} };
 
      
关于多维数组的案例可以看我以前讲解的Code：https://github.com/dunitian/LoTCodeBase/tree/master/NetCode/1.面向过程/02.数组系列
 
      
     
    
   
 
    

        
    
 
    
 
     
 
      
3.Python元组相关¶
 
      
3.1.元组定义、遍历等¶
 
      
定义：xxx=(xxx,xxx,xxx)
 
      
定义一个元素的元组：xxx=(1,)
 
     
 
    
 
   
 
   
 
    
 
     

       In [61]: 
     
 
     
 
      
 
       
 
        
# 只能查询，其他操作和列表差不多（不可变）(最后面有可变扩展)
test_tuple=("萌萌哒",1,3,5,"加息","加息")

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [62]: 
     
 
     
 
      
 
       
 
        
# 定义的扩展：
test_tuple1=(1,) #(1)就不是元祖了
test_tuple2=(2)
print(type(test_tuple1))
print(type(test_tuple2))

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        



 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [63]: 
     
 
     
 
      
 
       
 
        
# count index
print(test_tuple.count("加息"))
print(test_tuple.index("萌萌哒"))#没有find方法

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
2
0

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [64]: 
     
 
     
 
      
 
       
 
        
# 从特定位置查找，注意是左闭右开区间==>[1,4)
print(test_tuple.index("加息", 1, 4))#查不到报错：ValueError: tuple.index(x): x not in tuple

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
 in ()
      1 # 从特定位置查找，注意是左闭右开区间==>[1,4)
----> 2print(test_tuple.index("加息", 1, 4))#查不到报错：ValueError: tuple.index(x): x not in tuple

ValueError: tuple.index(x): x not in tuple
 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [65]: 
     
 
     
 
      
 
       
 
        
#下标取
print(test_tuple[0])
print(test_tuple[-1])

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
萌萌哒
加息

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [66]: 
     
 
     
 
      
 
       
 
        
# 遍历方式1
for item in test_tuple:
    print(item)

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
萌萌哒
1
3
5
加息
加息

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [67]: 
     
 
     
 
      
 
       
 
        
# 遍历方式2
i=0
while i<len(test_tuple):
    print(test_tuple[i])
    i+=1

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
萌萌哒
1
3
5
加息
加息

 
       
 
      
 
     
 
    
 
   
 
   
 
    

        
    
 
    
 
     
 
      
3.2.拆包、多维元组¶
 
      
先来说说 拆包相关的知识
 
      
a=(1,2)
 
      
b=a # 把a的引用给b
 
      
c,d=a # 不是把a分别赋值给c和d，等价于：c=a[0] d=a[1]
 
     
 
    
 
   
 
   
 
    
 
     

       In [68]: 
     
 
     
 
      
 
       
 
        
# 后面讲字典遍历的时候会再提一下的
a=(1,2)
b=a#把a的引用给b
#a里面两个值,直接给左边两个变量赋值了（有点像拆包了）
c,d=a #不是把a分别赋值给c和d，等价于：c=a[0] d=a[1]

print(a)
print(b)
print(c)
print(d)

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
(1, 2)
(1, 2)
1
2

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [69]: 
     
 
     
 
      
 
       
 
        
# 交换两数～元组的方式
a=1
b=2
a,b=b,a # 写全：(a,b)=(b,a)
print(a)
print(b)

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
2
1

 
       
 
      
 
     
 
    
 
   
 
   
 
    

        
    
 
    
 
     
 
      
多维元组
 
      
some_tuples=[(2,"萌萌哒"),(4,3)]
 
      
some_tuples[0]
 
      
some_tuples[0][1]
 
     
 
    
 
   
 
   
 
    
 
     

       In [70]: 
     
 
     
 
      
 
       
 
        
# 多维元组
some_tuples=[(2,"萌萌哒"),(4,3)]
some_tuples[0]
some_tuples[0][1]

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

         Out[70]: 
       
 
       
 
        
'萌萌哒'
 
       
 
      
 
     
 
    
 
   
 
   
 
    

        
    
 
    
 
     
 
      
3.3.可变元组¶
 
      
可变的元组（元组在定义的时候就不能变了，但是可以通过类似这种方式来改变）
 
      
案例里面用到了列表和字典（本章有讲解，这边你先看看）
 
      
参照C#的可变元组会更容易懂
 
     
 
    
 
   
 
   
 
    
 
     

       In [71]: 
     
 
     
 
      
 
       
 
        
# 扩展：可变的元组（元组在定义的时候就不能变了，但是可以通过类似这种方式来改变）
value_tuple = ("a", "1", ["mmd"],{"name":"dnt"})

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [72]: 
     
 
     
 
      
 
       
 
        
value_tuple

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

         Out[72]: 
       
 
       
 
        
('a', '1', ['mmd'], {'name': 'dnt'})
 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [73]: 
     
 
     
 
      
 
       
 
        
value_tuple[2].append("test")
print(value_tuple)

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
('a', '1', ['mmd', 'test'], {'name': 'dnt'})

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [74]: 
     
 
     
 
      
 
       
 
        
value_tuple[3]["wechat"]="dotnetcrazy"
print(value_tuple)

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
('a', '1', ['mmd', 'test'], {'name': 'dnt', 'wechat': 'dotnetcrazy'})

 
       
 
      
 
     
 
    
 
   
 
   
 
    

        
    
 
    
 
     
 
      
4.CSharp元组相关¶
 
      
逆天ValueTuple用的比较多，下面案例就是用的这个
 
      
元组系:https://msdn.microsoft.com/zh-cn/library/system.tuple.aspx
 
      
值元组:https://msdn.microsoft.com/zh-cn/library/system.valuetuple.aspx
 
      
C#中元组主要是方便程序员,不用自然可以。比如:当你返回多个值是否还用ref out 或者返回一个list之类的？
 
      
这些都需要先定义,比较麻烦.元祖在这些场景用的比较多。
 
      
先说说基本使用：
 
      
初始化：var test_tuple = ("萌萌哒", 1, 3, 5, "加息", "加息");
 
      
这种方式就是valueTuple了（看vscode监视信息）
 
      
Python3 与 C# 基础语法对比（List、Tuple、Dict、Set专栏）_第1张图片
 
      
 
       
// 初始化
var test_tuple = ("萌萌哒", 1, 3, 5, "加息", "加息"); //这种方式就是valueTuple了
test_tuple.Item1 = "ddd";//可以修改值
test_tuple.GetType();

 
      
 
      
需要说下的是，取值只能通过itemxxx来取了，然后就是valueTuple的值是可以修改的
 
      
Python3 与 C# 基础语法对比（List、Tuple、Dict、Set专栏）_第2张图片
 
      
下面直接进入应用场景：
 
      
 
       
var result = GetCityAndTel();  //支持async/await模式
var city = result.city;
var tel = result.tel;
// 拆包方式:
var (city1, tel1) = GetCityAndTel();

 
      
 
      
贴一下方法：
 
      
 
       
// public static (string city, string tel) GetCityAndTel()
// {
//     return ("北京", "110");
// }
// 简化写法
public static (string city, string tel) GetCityAndTel() => ("北京", "110");

 
      
 
      
再说一下，C#元组的方式交换两数：
 
      
 
       
int x = 1, y = 2;
(x, y) = (y, x);
Console.WriteLine("x： " + x + "  y： " + x);

 
      
 
      
PS：附上Python进行对比记忆：
 
      
 
       
a=1
b=2
a,b=b,a # 写全：(a,b)=(b,a)

 
      
 
      
就说到这了，简单了解即可
 
     
 
    
 
   
 
   
 
    

        
    
 
    
 
     
 
      
5.Python字典系列¶
 
      
5.1.字典定义、遍历¶
 
      
主要解析一下这个：
 
      
 
       
for k,v in infos_dict.items():
　　print("Key:%s,Value:%s"%(k,v))

 
      
 
      
每一次相当于取一个元组，那可以用之前讲的例子来简化了：c,d=a 等价于：c=a[0] d=a[1]
 
     
 
    
 
   
 
   
 
    
 
     

       In [75]: 
     
 
     
 
      
 
       
 
        
infos_dict={"name":"dnt","web":"dkill.net"} #空字典定义 dict={}

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [76]: 
     
 
     
 
      
 
       
 
        
# 遍历keys
for item in infos_dict.keys():
    print(item)

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
name
web

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [77]: 
     
 
     
 
      
 
       
 
        
#注意，如果你直接对infos遍历，其实只是遍历keys
for item in infos_dict:
    print(item)

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
name
web

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [78]: 
     
 
     
 
      
 
       
 
        
# 遍历values
for item in infos_dict.values():
    print(item)

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
dnt
dkill.net

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [79]: 
     
 
     
 
      
 
       
 
        
# 遍历键值对
for item in infos_dict.items():
    print("Key:%s,Value:%s"%(item[0],item[1]))

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
Key:name,Value:dnt
Key:web,Value:dkill.net

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [80]: 
     
 
     
 
      
 
       
 
        
# 每一次相当于取一个元组，那可以用之前讲的例子来简化了：c,d=a #等价于：c=a[0] d=a[1]
for k,v in infos_dict.items():
    print("Key:%s,Value:%s"%(k,v))

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
Key:name,Value:dnt
Key:web,Value:dkill.net

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [81]: 
     
 
     
 
      
 
       
 
        
# 活学活用，用列表生成式列表
[k + ':' + v for k,v in infos_dict.items()]

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

         Out[81]: 
       
 
       
 
        
['name:dnt', 'web:dkill.net']
 
       
 
      
 
     
 
    
 
   
 
   
 
    

        
    
 
    
 
     
 
      
5.2.增加和修改¶
 
      
增加、修改：infos_dict["wechat"]="dotnetcrazy" # 有就修改，没就添加
 
     
 
    
 
   
 
   
 
    
 
     

       In [82]: 
     
 
     
 
      
 
       
 
        
# 增加 修改 (有就修改，没就添加)
# 添加
infos_dict["wechat"]="lll"
print(infos_dict)

# 修改
infos_dict["wechat"]="dotnetcrazy"
print(infos_dict)

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
{'name': 'dnt', 'web': 'dkill.net', 'wechat': 'lll'}
{'name': 'dnt', 'web': 'dkill.net', 'wechat': 'dotnetcrazy'}

 
       
 
      
 
     
 
    
 
   
 
   
 
    

        
    
 
    
 
     
 
      
补充：dict内部存放的顺序和key放入的顺序是没有关系的
 
      
dict的key必须是 不可变对象，dict根据key进行hash算法,来计算value的存储位置
 
      
如果每次计算相同的key得出的结果不同，那dict内部就完全混乱了
 
      
测试结果：元组是可以作为Key的
 
     
 
    
 
   
 
   
 
    
 
     

       In [83]: 
     
 
     
 
      
 
       
 
        
# dict的key必须是不可变对象的验证案例
key1=(1,2,3)
key2=[1,2,3]
key3={"1":"2"}

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [84]: 
     
 
     
 
      
 
       
 
        
dic={}

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [85]: 
     
 
     
 
      
 
       
 
        
# 元组是不可变类型，可以当key
dic[key1]="mmd"

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [86]: 
     
 
     
 
      
 
       
 
        
# dict根据key进行hash算法,来计算value的存储位置
# 如果每次计算相同的key得出的结果不同，那dict内部就完全混乱了
dic[key2]="dnt" # unhashable

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
 in ()
      1 # dict根据key进行hash算法,来计算value的存储位置
      2 # 如果每次计算相同的key得出的结果不同，那dict内部就完全混乱了
----> 3dic[key2]="dnt" # unhashable

TypeError: unhashable type: 'list'
 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [87]: 
     
 
     
 
      
 
       
 
        
# 字典也不行
dic[key3]="test"

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
 in ()
      1 # 字典也不行
----> 2dic[key3]="test"

TypeError: unhashable type: 'dict'
 
       
 
      
 
     
 
    
 
   
 
   
 
    

        
    
 
    
 
     
 
      
5.3.删除¶
 
      
删除系列：
 
      
清空字典内容 infos_dict.clear()
 
      
删除指定内容 del infos_dict["name"]（没有返回值） or pop(key)（返回删除Key的值） 不存在都会报错
 
      
删除字典 del infos_dict
 
     
 
    
 
   
 
   
 
    
 
     

       In [88]: 
     
 
     
 
      
 
       
 
        
infos_dict #查看列表

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

         Out[88]: 
       
 
       
 
        
{'name': 'dnt', 'web': 'dkill.net', 'wechat': 'dotnetcrazy'}
 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [89]: 
     
 
     
 
      
 
       
 
        
# 要删除一个key，用pop(key)方法，对应的value也会从dict中删除
infos_dict.pop("wechat") #返回key对应的值

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

         Out[89]: 
       
 
       
 
        
'dotnetcrazy'
 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [90]: 
     
 
     
 
      
 
       
 
        
infos_dict.pop("wechat") #key不存在，则报错

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
 in ()
----> 1infos_dict.pop("wechat") #key不存在，则报错

KeyError: 'wechat'
 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [91]: 
     
 
     
 
      
 
       
 
        
del infos_dict["name"] #没有返回值
print(infos_dict)

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
{'web': 'dkill.net'}

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [92]: 
     
 
     
 
      
 
       
 
        
del infos_dict["name"] #不存在就报错

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
 in ()
----> 1del infos_dict["name"] #不存在就报错

KeyError: 'name'
 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [93]: 
     
 
     
 
      
 
       
 
        
#清空字典内容
infos_dict.clear()
print(infos_dict)

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
{}

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [94]: 
     
 
     
 
      
 
       
 
        
# 删除字典
del infos_dict

 
       
 
      
 
     
 
    
 
   
 
   
 
    

        
    
 
    
 
     
 
      
5.4.查询¶
 
      
查询系列：推荐：infos_dict.get("mmd") # 查不到不会异常
 
     
 
    
 
   
 
   
 
    
 
     

       In [95]: 
     
 
     
 
      
 
       
 
        
infos_dict={"name":"dnt","web":"dkill.net"} #刚才被删掉了，我们重新定义一下

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [96]: 
     
 
     
 
      
 
       
 
        
infos_dict["name"]

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

         Out[96]: 
       
 
       
 
        
'dnt'
 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [97]: 
     
 
     
 
      
 
       
 
        
infos_dict["mmd"] #查不到就异常

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
 in ()
----> 1infos_dict["mmd"] #查不到就异常

KeyError: 'mmd'
 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [98]: 
     
 
     
 
      
 
       
 
        
# 要避免key不存在的错误，有两种办法
# 一是通过in判断key是否存在：
print("mmd" in infos_dict)

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
False

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [99]: 
     
 
     
 
      
 
       
 
        
# 二是通过dict提供的get()方法
infos_dict.get("name")
print(infos_dict.get("mmd"))#如果key不存在，返回None
print(infos_dict.get("mmd",-1))#也可以返回自己指定的value

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
None
-1

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [100]: 
     
 
     
 
      
 
       
 
        
# 查看帮助
# help(infos_dict)
len(infos_dict) #有几对key,value 
# infos_dict.has_key("name") #这个是python2里面的

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

         Out[100]: 
       
 
       
 
        
2
 
       
 
      
 
     
 
    
 
   
 
   
 
    

        
    
 
    
 
     
 
      
6.CSharp字典系列¶
 
      
6.1.定义、遍历¶
 
      
C#的字典操作大家比较熟悉了，而且挺简单的，就一笔带过了
 
      
 
       
//定义
var infos_dict = new Dictionary<string, object>{
                {"name","dnt"},
                {"web","dkill.net"}
            };
//遍历
foreach (KeyValuePair<string, object> kv in infos_dict)
{
　　Console.WriteLine($"Key:{kv.Key},Value:{kv.Value}");
}

 
      
 
     
 
    
 
   
 
   
 
    

        
    
 
    
 
     
 
      
6.2.增删改查¶
 
      
 
       
//添加
infos_dict.Add("wechat", "lll");
infos_dict["wechat1"] = "lll";

//修改
infos_dict["wechat"] = "dotnetcrazy";

 
      
 
      
删除系列：
 
      
 
       
// 删除元素
// # del infos_dict["name"]
// # del infos_dict["dog"] #不存在就报错
// # print(infos_dict)
infos_dict.Remove("name");
infos_dict.Remove("dog");//不存在不报错
// 清空列表内容
// # infos_dict.clear()
// # print(infos_dict)
infos_dict.Clear();

 
      
 
      
查询系列：
 
      
 
       
// infos_dict["name"]
// infos_dict["mmd"] #查不到就异常            
// infos_dict.get("name")
// infos_dict.get("mmd")#查不到不会异常
Console.WriteLine(infos_dict["name"]);
// Console.WriteLine(infos_dict["mmd"]); //#查不到就异常
// 先看看有没有 ContainsKey(key),看值就 ContainsValue(value)
if (infos_dict.ContainsKey("mmd")) Console.WriteLine(infos_dict["mmd"]);

// len(infos_dict) #有几对key,value
Console.WriteLine(infos_dict.Count);

 
      
 
     
 
    
 
   
 
   
 
    

        
    
 
    
 
     
 
      
7.集合Set¶
 
      
7.1.定义、遍历¶
 
      
定义：set(iterable)
 
      
eg:set([1,2,1,"mmd"]) 基本上能for循环的都可以（list，tuple，dict，str）
 
      
如果是字符串，则拆分成单个字符集合 set("abc")
 
      
集合Set注意个东西：（list去重一般就和set结合使用）
 
      
重复元素在自动被过滤(数学里面的集合也是没有重复元素的)
 
      
遍历：
 
      
 
       
for item in my_set:
    print(item)

 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [101]: 
     
 
     
 
      
 
       
 
        
# 先看个帮助文档
help(set)

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
Help on class set in module builtins:

class set(object)
 |  set() -> new empty set object
 |  set(iterable) -> new set object
 |  
 |  Build an unordered collection of unique elements.
 |  
 |  Methods defined here:
 |  
 |  __and__(self, value, /)
 |      Return self&value.
 |  
 |  __contains__(...)
 |      x.__contains__(y) <==> y in x.
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __iand__(self, value, /)
 |      Return self&=value.
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __ior__(self, value, /)
 |      Return self|=value.
 |  
 |  __isub__(self, value, /)
 |      Return self-=value.
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __ixor__(self, value, /)
 |      Return self^=value.
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self size of S in memory, in bytes
 |  
 |  __sub__(self, value, /)
 |      Return self-value.
 |  
 |  __xor__(self, value, /)
 |      Return self^value.
 |  
 |  add(...)
 |      Add an element to a set.
 |      
 |      This has no effect if the element is already present.
 |  
 |  clear(...)
 |      Remove all elements from this set.
 |  
 |  copy(...)
 |      Return a shallow copy of a set.
 |  
 |  difference(...)
 |      Return the difference of two or more sets as a new set.
 |      
 |      (i.e. all elements that are in this set but not the others.)
 |  
 |  difference_update(...)
 |      Remove all elements of another set from this set.
 |  
 |  discard(...)
 |      Remove an element from a set if it is a member.
 |      
 |      If the element is not a member, do nothing.
 |  
 |  intersection(...)
 |      Return the intersection of two sets as a new set.
 |      
 |      (i.e. all elements that are in both sets.)
 |  
 |  intersection_update(...)
 |      Update a set with the intersection of itself and another.
 |  
 |  isdisjoint(...)
 |      Return True if two sets have a null intersection.
 |  
 |  issubset(...)
 |      Report whether another set contains this set.
 |  
 |  issuperset(...)
 |      Report whether this set contains another set.
 |  
 |  pop(...)
 |      Remove and return an arbitrary set element.
 |      Raises KeyError if the set is empty.
 |  
 |  remove(...)
 |      Remove an element from a set; it must be a member.
 |      
 |      If the element is not a member, raise a KeyError.
 |  
 |  symmetric_difference(...)
 |      Return the symmetric difference of two sets as a new set.
 |      
 |      (i.e. all elements that are in exactly one of the sets.)
 |  
 |  symmetric_difference_update(...)
 |      Update a set with the symmetric difference of itself and another.
 |  
 |  union(...)
 |      Return the union of sets as a new set.
 |      
 |      (i.e. all elements that are in either set.)
 |  
 |  update(...)
 |      Update a set with the union of itself and others.
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __hash__ = None


 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [102]: 
     
 
     
 
      
 
       
 
        
# 定义一个set集合
# set(iterable) -> new set object #列表就比较合适了
my_set=set([1,2,1,"mmd"])

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [103]: 
     
 
     
 
      
 
       
 
        
# 数学里面也是用大括号表示的
my_set # 重复元素在自动被过滤

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

         Out[103]: 
       
 
       
 
        
{1, 2, 'mmd'}
 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [104]: 
     
 
     
 
      
 
       
 
        
my_set=set((1,2,3,3,2))

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [105]: 
     
 
     
 
      
 
       
 
        
my_set

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

         Out[105]: 
       
 
       
 
        
{1, 2, 3}
 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [106]: 
     
 
     
 
      
 
       
 
        
# 只会存不重复的key值
my_set=set({"name":"mmd","name":"ddd","age":22})

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [107]: 
     
 
     
 
      
 
       
 
        
my_set

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

         Out[107]: 
       
 
       
 
        
{'age', 'name'}
 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [108]: 
     
 
     
 
      
 
       
 
        
# 遍历 my_set
for item in my_set:
    print(item)

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
age
name

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [109]: 
     
 
     
 
      
 
       
 
        
# list去重案例：
my_list=[1,111,22,33,1,1,1]
my_list=list(set(my_list))
print(my_list)

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
[1, 33, 22, 111]

 
       
 
      
 
     
 
    
 
   
 
   
 
    

        
    
 
    
 
     
 
      
7.2.增删改系列¶
 
      
添加元素：
 
      
add() 添加一个元素
 
      
update() 添加一些元素
 
      
删除系列：
 
      
discard() 有就删除，没有不会报错
 
     
 
    
 
   
 
   
 
    
 
     

       In [110]: 
     
 
     
 
      
 
       
 
        
# 添加元素
my_set.add("add") #没有返回值
print(my_set)

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
{'add', 'age', 'name'}

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [111]: 
     
 
     
 
      
 
       
 
        
# 添加一些元素
my_set.update([1,4,3])
print(my_set)

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
{1, 3, 4, 'age', 'name', 'add'}

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [112]: 
     
 
     
 
      
 
       
 
        
my_set.update((6,7,9))
print(my_set)

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
{1, 3, 4, 6, 7, 9, 'age', 'name', 'add'}

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [113]: 
     
 
     
 
      
 
       
 
        
# 字符串被拆成字符存储
my_set.update("Love")
print(my_set)

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
{1, 'o', 3, 4, 6, 7, 'L', 9, 'age', 'v', 'name', 'add', 'e'}

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [114]: 
     
 
     
 
      
 
       
 
        
################### 删除系列 ###########################

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [115]: 
     
 
     
 
      
 
       
 
        
# 删除元素
my_set.remove("mmd") # 不存在则报错
print(my_set)

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
 in ()
      1 # 删除元素
----> 2my_set.remove("mmd") # 不存在则报错
      3 print(my_set)

KeyError: 'mmd'
 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [116]: 
     
 
     
 
      
 
       
 
        
# 删除 name
my_set.remove("name")

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [117]: 
     
 
     
 
      
 
       
 
        
my_set

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

         Out[117]: 
       
 
       
 
        
{1, 3, 4, 6, 7, 9, 'L', 'add', 'age', 'e', 'o', 'v'}
 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [118]: 
     
 
     
 
      
 
       
 
        
# pop删除
# pop一般不用，说法不一，有些说删除第一个有些说随机
# 了解就好了，不用管pop（全数字的时候，我测试的确删的是第一个）
my_set.pop()

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

         Out[118]: 
       
 
       
 
        
1
 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [119]: 
     
 
     
 
      
 
       
 
        
my_set

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

         Out[119]: 
       
 
       
 
        
{3, 4, 6, 7, 9, 'L', 'add', 'age', 'e', 'o', 'v'}
 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [120]: 
     
 
     
 
      
 
       
 
        
# 清空
my_set.clear()

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [121]: 
     
 
     
 
      
 
       
 
        
my_set

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

         Out[121]: 
       
 
       
 
        
set()
 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [122]: 
     
 
     
 
      
 
       
 
        
# 有就删除，没有也不会报错
my_set.discard("dnt") # 没有返回值

 
       
 
      
 
     
 
    
 
   
 
   
 
    

        
    
 
    
 
     
 
      
7.3.交、并、差、子集¶
 
     
 
    
 
   
 
   
 
    
 
     

       In [123]: 
     
 
     
 
      
 
       
 
        
#利用运算符+set 实现数学方面的扩展
set1=set([1,2,5])
set2=set([2,4,6])

print(set1)
print(set2)

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
{1, 2, 5}
{2, 4, 6}

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [124]: 
     
 
     
 
      
 
       
 
        
# 交集 A∩B={x|x∈A,且x∈B}
set1 & set2

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

         Out[124]: 
       
 
       
 
        
{2}
 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [125]: 
     
 
     
 
      
 
       
 
        
# 并集 A∪B={x|x∈A,或x∈B}
set1 | set2

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

         Out[125]: 
       
 
       
 
        
{1, 2, 4, 5, 6}
 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [126]: 
     
 
     
 
      
 
       
 
        
# 差集 A-B={x∣x∈A,且x∉B}
set1 - set2

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

         Out[126]: 
       
 
       
 
        
{1, 5}
 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [127]: 
     
 
     
 
      
 
       
 
        
# 对称差集（互相没有的取出来）
set1^set2

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

         Out[127]: 
       
 
       
 
        
{1, 4, 5, 6}
 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [128]: 
     
 
     
 
      
 
       
 
        
# Set方法实现交集
set1.intersection(set2)

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

         Out[128]: 
       
 
       
 
        
{2}
 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [129]: 
     
 
     
 
      
 
       
 
        
# Set方法去重后的并集
set1.union(set2)

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

         Out[129]: 
       
 
       
 
        
{1, 2, 4, 5, 6}
 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [130]: 
     
 
     
 
      
 
       
 
        
# 差集（把set1里面有的而set2里面没有的取出）
set1.difference(set2)

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

         Out[130]: 
       
 
       
 
        
{1, 5}
 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [131]: 
     
 
     
 
      
 
       
 
        
# 对称差集（互相没有的取出来）
set1.symmetric_difference(set2)

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

         Out[131]: 
       
 
       
 
        
{1, 4, 5, 6}
 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [132]: 
     
 
     
 
      
 
       
 
        
# 再定义两个Set用来进行下面调试
set3=set([1,2])
set4=set([7,8,9])

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [133]: 
     
 
     
 
      
 
       
 
        
# 子集（判断set3是否是set1的子集）
set3.issubset(set1)

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

         Out[133]: 
       
 
       
 
        
True
 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [134]: 
     
 
     
 
      
 
       
 
        
# 父集（set1是否是set3的父集）
set1.issuperset(set3)

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

         Out[134]: 
       
 
       
 
        
True
 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [135]: 
     
 
     
 
      
 
       
 
        
# 判断两个集合是否没有交集
set1.isdisjoint(set4)

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

         Out[135]: 
       
 
       
 
        
True
 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [136]: 
     
 
     
 
      
 
       
 
        
# 反过来也一样
set4.isdisjoint(set1)

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

         Out[136]: 
       
 
       
 
        
True
 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [137]: 
     
 
     
 
      
 
       
 
        
################### 补集的扩展 ###########################

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [138]: 
     
 
     
 
      
 
       
 
        
# 补集
set3=set(list(range(10)))

print(set3)

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [139]: 
     
 
     
 
      
 
       
 
        
# 【大前提】set2是set3的一个子集（set3包含于set2）
set2.issubset(set3)

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

         Out[139]: 
       
 
       
 
        
True
 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [140]: 
     
 
     
 
      
 
       
 
        
# 这时候求差集，就等于求补集
set3 - set2

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

         Out[140]: 
       
 
       
 
        
{0, 1, 3, 5, 7, 8, 9}
 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [141]: 
     
 
     
 
      
 
       
 
        
# 其他内容可以直接查看help

 
       
 
      
 
     
 
    
 
   
 
   
 
    

        
    
 
    
 
     
 
      
8.Python扩展¶
 
      
8.1.运算符扩展¶
 
      
+ 合并，* 复制，in 是否存在（字典是查key），not in 是否不存在（字典是查key）
 
     
 
    
 
   
 
   
 
    
 
     

       In [142]: 
     
 
     
 
      
 
       
 
        
test_str="www.baidu.com"
test_list=[1,"d",5]
test_list1=[2,4,"n","t",3]
test_dict={"name":"dnt","wechat":"xxx"}

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [143]: 
     
 
     
 
      
 
       
 
        
# + 合并 (不支持字典)
print(test_str+test_str)
print(test_list+test_list1)

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
www.baidu.comwww.baidu.com
[1, 'd', 5, 2, 4, 'n', 't', 3]

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [144]: 
     
 
     
 
      
 
       
 
        
# * 复制 (不支持字典)
print(test_str*2)
print(test_list*2)

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
www.baidu.comwww.baidu.com
[1, 'd', 5, 1, 'd', 5]

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [145]: 
     
 
     
 
      
 
       
 
        
# in 是否存在（字典是查key）
print("d" in test_str)          #True
print("d" in test_list)         #True
print("d" in test_dict)         #False
print("name" in test_dict)      #True

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
True
True
False
True

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [146]: 
     
 
     
 
      
 
       
 
        
# not in 是否不存在（字典是查key）
print("z" not in test_str)      #True
print("z" not in test_list)     #True
print("z" not in test_dict)     #True
print("name" not in test_dict)  #False

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
True
True
True
False

 
       
 
      
 
     
 
    
 
   
 
   
 
    

        
    
 
    
 
     
 
      
8.2.内置函数扩展¶
 
      
len，max，min，del
 
      
len()，这个就不说了，用的太多了
 
      
max()，求最大值，dict的最大值是比较的key
 
      
min()，这个和max一样用，最小值
 
     
 
    
 
   
 
   
 
    
 
     

       In [147]: 
     
 
     
 
      
 
       
 
        
# len(item) 计算容器中元素个数
print(len(test_str))
print(len(test_list))
print(len(test_dict))

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
13
3
2

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [148]: 
     
 
     
 
      
 
       
 
        
# max(item) 返回容器中元素最大值
max(test_str)

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

         Out[148]: 
       
 
       
 
        
'w'
 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [149]: 
     
 
     
 
      
 
       
 
        
# 这个注意一种情况（当然了，你按照之前说的规范，list里面放同一种类型就不会出错了）
max(test_list) #TypeError: '>' not supported between instances of 'str' and 'int'

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
 in ()
      1 # 这个注意一种情况（当然了，你按照之前说的规范，list里面放同一种类型就不会出错了）
----> 2max(test_list) #TypeError: '>' not supported between instances of 'str' and 'int'

TypeError: '>' not supported between instances of 'str' and 'int'
 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [150]: 
     
 
     
 
      
 
       
 
        
test_list=[1,3,5,7,9,2]
print(max(test_list))
print(max(test_dict)) #比较key

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
9
wechat

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [151]: 
     
 
     
 
      
 
       
 
        
# min(item) 返回容器中元素最小值
print(min(test_str))
print(min(test_list))
print(min(test_dict))

 
       
 
      
 
     
 
    
 
    
 
     
 
      
 
       

           
       
 
       
 
        
.
1
name

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [ ]: 
     
 
     
 
      
 
       
 
        
# del(item)	        删除变量
# del() or del xxx

 
       
 
      
 
     
 
    
 
   
 
   
 
    
 
     

       In [ ]: 
     
 
     
 
      
 
       
 
        
# 可以忽略 cmp(item1, item2) 比较两个值
# Python2里面有 cmp(1,2) ==> -1 
# cmp在比较字典数据时，先比较键，再比较值

 
       
 
      
 
     
 
    
 
   
 
   
  
转载于:https://www.cnblogs.com/dotnetcrazy/p/9155310.html
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Python3 与 C# 基础语法对比（List、Tuple、Dict、Set专栏）)

        

            

                
    
                    
  • 斤斤计较的婚姻到底有多难？
                        白心之岂必有为

                        
    很多人私聊我会问到在哪个人群当中斤斤计较的人最多？我都会回答他，一般婚姻出现问题的斤斤计较的人士会非常多，以我多年经验，在婚姻落的一塌糊涂的人当中，斤斤计较的人数占比在20～30%以上，也就是说10个婚姻出现问题的斤斤计较的人有2-3个有多不减。在婚姻出问题当中，有大量的心理不平衡的、尖酸刻薄的怨妇。在婚姻中仅斤斤计较有两种类型：第一种是物质上的，另一种是精神上的。在物质与精神上抠门已经严重的影响
    
                    
    • 
                    
  • QQ群采集助手，精准引流必备神器
                        2401_87347160
其他经验分享
                        
    功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
    
                    
    • 
                    
  • 机器学习与深度学习间关系与区别
                        ℒℴѵℯ心·动ꦿ໊ོ꫞
人工智能学习深度学习python
                        
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
    
                    
    • 
                    
  • 随笔 | 仙一般的灵气
                        海思沧海

                        
    仙岛今天，我看了你全部，似乎已经进入你的世界我不知道，这是否是梦幻，还是你仙一般的灵气吸引了我也许每一个人都要有一份属于自己的追求，这样才能够符合人生的梦想，生活才能够充满着阳光与快乐我不知道，我为什么会这样的感叹，是在感叹自己的人生，还是感叹自己一直没有孜孜不倦的追求只感觉虚度了光阴，每天活在自己的梦中，活在一个不真实的世界是在逃避自己，还是在逃避周围的一切有时候我嘲笑自己，嘲笑自己如此的虚无，
    
                    
    • 
                    
  • 一百九十四章. 自相矛盾
                        巨木擎天

                        
    唉！就这么一夜，林子感觉就像过了很多天似的，先是回了阳间家里，遇到了那么多不可思议的事情儿。特别是小伙伴们，第二次与自己见面时，僵硬的表情和恐怖的气氛，让自己如坐针毡，打从心眼里难受！还有东子，他现在还好吗？有没有被人欺负？护城河里的小鱼小虾们，还都在吗？水不会真的干枯了吧？那对相亲相爱漂亮的太平鸟儿，还好吧！春天了，到了做窝、下蛋、喂养小鸟宝宝的时候了，希望它们都能够平安啊！虽然没有看见家人，也
    
                    
    • 
                    
  • 微服务下功能权限与数据权限的设计与实现
                        nbsaas-boot
微服务java架构
                        
    在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
    
                    
    • 
                    
  • 学点心理知识，呵护孩子健康
                        静候花开_7090

                        
    昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
    
                    
    • 
                    
  • 《投行人生》读书笔记
                        小蘑菇的树洞

                        
    《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
    
                    
    • 
                    
  • Long类型前后端数据不一致
                        igotyback
前端
                        
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
    
                    
    • 
                    
  • 店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码
                        说私域
人工智能小程序
                        
    摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
    
                    
    • 
                    
  • 2021-08-26
                        影幽

                        
    在生活中，女人与男人的感悟往往有所不同。人生最大的舞台就是生活，大幕随时都可能拉开，关键是你愿不愿意表演都无法躲避。在生活中，遇事不要急躁，不要急于下结论，尤其生气时不要做决断，要学会换位思考，大事化小小事化了，把复杂的事情尽量简单处理，千万不要把简单的事情复杂化。永远不要扭曲，别人善意，无药可救。昨天是张过期的支票，明天是张信用卡，只有今天才是现金，要善加利用！执着的攀登者不必去与别人比较自己的
    
                    
    • 
                    
  • ArcGIS栅格计算器常见公式（赋值、0和空值的转换、补充栅格空值）
                        研学随笔
arcgis经验分享
                        
    我们在使用ArcGIS时通常经常用到栅格计算器，今天主要给大家介绍我日常中经常用到的几个公式，供大家参考学习。将特定值（-9999）赋值为0，例如-9999.Con("raster"==-9999,0,"raster")2.给空值赋予特定的值（如0）Con(IsNull("raster"),0,"raster")3.将特定的栅格值(如1)赋值为空值，其他保留原值SetNull("raster"==
    
                    
    • 
                    
  • 高级编程--XML+socket练习题
                        masa010
java开发语言
                        
    1.北京华北2114.8万人上海华东2,500万人广州华南1292.68万人成都华西1417万人（1）使用dom4j将信息存入xml中（2）读取信息，并打印控制台（3）添加一个city节点与子节点（4）使用socketTCP协议编写服务端与客户端，客户端输入城市ID，服务器响应相应城市信息（5）使用socketTCP协议编写服务端与客户端，客户端要求用户输入city对象，服务端接收并使用dom4j
    
                    
    • 
                    
  • 2018-07-23-催眠日作业-#不一样的31天#-66小鹿
                        小鹿_33

                        
    预言日：人总是在逃避命运的路上，与之不期而遇。心理学上有个著名的名词，叫做自证预言；经济学上也有一个很著名的定律叫做，墨菲定律；在灵修派上，还有一个很著名的法则，叫做吸引力法则。这3个领域的词，虽然看起来不太一样，但是他们都在告诉人们一个现象：你越担心什么，就越有可能会发生什么。同样的道理，你越想得到什么，就应该要积极地去创造什么。无论是自证预言，墨菲定律还是吸引力法则，对人都有正反2个维度的影响
    
                    
    • 
                    
  • 回溯 Leetcode 332 重新安排行程
                        mmaerd
Leetcode刷题学习记录leetcode算法职场和发展
                        
    重新安排行程Leetcode332学习记录自代码随想录给你一份航线列表tickets，其中tickets[i]=[fromi,toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。例如，行程[“JFK”,“LGA”]与[“JFK”,“LGB
    
                    
    • 
                    
  • 每日一题——第九十题
                        互联网打工人no1
C语言程序设计每日一练c语言
                        
    题目：判断子串是否与主串匹配#include#include#include//////判断子串是否在主串中匹配//////主串///子串///boolisSubstring(constchar*str,constchar*substr){intlenstr=strlen(str);//计算主串的长度intlenSub=strlen(substr);//计算子串的长度//遍历主字符串，对每个可能得
    
                    
    • 
                    
  • Python数据分析与可视化实战指南
                        William数据分析
pythonpython数据
                        
    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
    
                    
    • 
                    
  • C#中使用split分割字符串
                        互联网打工人no1
c#
                        
    1、用字符串分隔：usingSystem.Text.RegularExpressions;stringstr="aaajsbbbjsccc";string[]sArray=Regex.Split(str,"js",RegexOptions.IgnoreCase);foreach(stringiinsArray)Response.Write(i.ToString()+"");输出结果：aaabbbc
    
                    
    • 
                    
  • WPF中的ComboBox控件几种数据绑定的方式
                        互联网打工人no1
wpfc#
                        
    一、用字典给ItemsSource赋值（此绑定用的地方很多，建议熟练掌握）在XMAL中：在CS文件中privatevoidBindData(){DictionarydicItem=newDictionary();dicItem.add(1,"北京");dicItem.add(2,"上海");dicItem.add(3,"广州");cmb_list.ItemsSource=dicItem;cmb_l
    
                    
    • 
                    
  • 《庄子.达生9》
                        钱江潮369

                        
    【原文】孔子观于吕梁，县水三十仞，流沫四十里，鼋鼍鱼鳖之所不能游也。见一丈夫游之，以为有苦而欲死也，使弟子并流而拯之。数百步而出，被发行歌而游于塘下。孔子从而问焉，曰：“吾以子为鬼，察子则人也。请问，‘蹈水有道乎’”曰：“亡，吾无道。吾始乎故，长乎性，成乎命。与齐俱入，与汩偕出，从水之道而不为私焉。此吾所以蹈之也。”孔子曰：“何谓始乎故，长乎性，成乎命？”曰：“吾生于陵而安于陵，故也；长于水而安于
    
                    
    • 
                    
  • 水泥质量纠纷案代理词
                        徐宝峰律师

                        
    贵州领航建设有限公司诉贵州纳雍隆庆乌江水泥有限公司产品质量纠纷案代理词尊敬的审判长、审判员：贵州千里律师事务所接受被告贵州纳雍隆庆乌江水泥有限公司的委托，指派我担任其诉讼代理人，参加本案的诉讼活动。下面，我结合本案事实和相关法律规定发表如下代理意见，供合议庭评议案件时参考：原告应当举证证明其遭受的损失与被告生产的水泥质量的因果关系。首先水泥是一种粉状水硬性无机胶凝材料。加水搅拌后成浆体，能在空气中
    
                    
    • 
                    
  • Goolge earth studio 进阶4——路径修改与平滑
                        陟彼高冈yu
Googleearthstudio进阶教程旅游
                        
    如果我们希望在大约中途时获得更多的城市鸟瞰视角。可以将相机拖动到这里并创建一个新的关键帧。camera_target_clip_7EarthStudio会自动平滑我们的路径，所以当我们通过这个关键帧时，不是一个生硬的角度，而是一个平滑的曲线。camera_target_clip_8路径上有贝塞尔控制手柄，允许我们调整路径的形状。右键单击，我们可以选择“平滑路径”，这是默认的自动平滑算法，或者我们可
    
                    
    • 
                    
  • 18-115 一切思考不能有效转化为行动，都TM是扯淡！
                        成长时间线

                        
    7月25号写了一篇关于为什么会断更如此严重的反思，然而，之后日更仅仅维持了一周，又出现了这次更严重的现象。从8月2号到昨天8月6号，5天！又是5天没有更文！虽然这次断更时间和上次一样，那为什么说这次更严重？因为上次之后就分析了问题的原因，以及应该如何解决，按理说应该会好转，然而，没过几天严重断更的现象再次出现，想想，经过反思，问题依然没有解决与改变，这让我有些担忧。到底是哪里出了问题，难道我就真的
    
                    
    • 
                    
  • 山东大学小树林支教调研团青青仓木队——翟晓楠
                        山东大学青青仓木队

                        
    过了半年，又一次启程，又一次回到支教的初心之地。比起上一次的试探与不安，我更多了一丝稳重与熟练。心境、处境也都随着半个学期的过去而变得不同，半个学期中，身体上的，心理上的，太多的逆境让我变得步履维艰，曲曲折折，弯弯绕绕，我仿佛打不起精神，没有胃口，没有动力。感觉走的不顺畅的时候，支教这个旅程，给了我力量。自告奋勇承担起队长这一职务的我，从组织时的复杂和困难的经历，协调各种问题，从无到有，和校长和队
    
                    
    • 
                    
  • 直返最高等级与直返APP：无需邀请码的返利新体验
                        古楼

                        
    随着互联网的普及和电商的兴起，直返模式逐渐成为一种流行的商业模式。在这种模式下，消费者通过购买产品或服务，获得一定的返利，并可以分享给更多的人。其中，直返最高等级和直返APP是直返模式中的重要概念和工具。本文将详细介绍直返最高等级的概念、直返APP的使用以及与邀请码的关系。【高省】APP（高佣金领导者）是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，运行三年，稳定可靠。高省APP，
    
                    
    • 
                    
  • SQL Server_查询某一数据库中的所有表的内容
                        qq_42772833
SQLServer数据库sqlserver
                        
    1.查看所有表的表名要列出CrabFarmDB数据库中的所有表（名），可以使用以下SQL语句：USECrabFarmDB;--切换到目标数据库GOSELECTTABLE_NAMEFROMINFORMATION_SCHEMA.TABLESWHERETABLE_TYPE='BASETABLE';对这段SQL脚本的解释：SELECTTABLE_NAME：这个语句的作用是从查询结果中选择TABLE_NAM
    
                    
    • 
                    
  • Git常用命令－修改远程仓库地址
                        猿大师
LinuxJavagitjava
                        
    查看远程仓库地址gitremote-v返回结果originhttps://git.coding.net/＊＊＊＊＊.git(fetch)originhttps://git.coding.net/＊＊＊＊＊.git(push)修改远程仓库地址gitremoteset-urloriginhttps://git.coding.net/＊＊＊＊＊.git先删除后增加远程仓库地址gitremotermori
    
                    
    • 
                    
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    
                    
    • 
                    
  • 2020-04-12每天三百字之连接与替代
                        冷眼看潮

                        
    不知道是不是好为人师，有时候还真想和别人分享一下我对某些现象的看法或者解释。人类社会不断发展进步的过程，就是不断连接与替代的过程。人类发现了火并应用火以后，告别了茹毛饮血的野兽般的原始生活（火烧、烹饪替代了生食）人类用石器代替了完全手工，工具的使用使人类进步一大步。类似这样的替代还有很多，随着科技的发展，有更多的原始的事物被替代，代之以更高效、更先进的技术。在近现代，汽车替代了马车，高速公路和铁路
    
                    
    • 
                    
  • 从0到500+，我是如何利用自媒体赚钱？
                        一列脚印

                        
    运营公众号半个多月，从零基础的小白到现在慢慢懂了一些运营的知识。做好公众号是很不容易的，要做很多事情；排版、码字、引流…通通需要自己解决，业余时间全都花费在这上面涨这么多粉丝是真的不容易，对比知乎大佬来说，我们这种没资源，没人脉，还没钱的小透明来说，想要一个月涨粉上万，怕是今天没睡醒（不过你有的方法，算我piapia打脸）至少我是清醒的，自己慢慢努力，实现我的万粉目标！大家快来围观、支持我吧！孩子
    
                    
    • 
                                
  • java线程的无限循环和退出
                                    3213213333332132
java
                                    
    最近想写一个游戏，然后碰到有关线程的问题，网上查了好多资料都没满足。 
突然想起了前段时间看的有关线程的视频，于是信手拈来写了一个线程的代码片段。 
希望帮助刚学java线程的童鞋 
 

package thread;

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date
    
                                
    • 
                                
  • tomcat 容器
                                    BlueSkator
tomcatWebservlet
                                    
    Tomcat的组成部分 1、server 
A Server element represents the entire Catalina servlet container. (Singleton) 2、service 
service包括多个connector以及一个engine，其职责为处理由connector获得的客户请求。 
  3、connector 
一个connector
    
                                
    • 
                                
  • php递归,静态变量,匿名函数使用
                                    dcj3sjt126com
PHP递归函数匿名函数静态变量引用传参
                                    
      
<!doctype html>
<html lang="en">
<head>
    <meta charset="utf-8">
    <title>Current To-Do List</title>
</head>
<body>
    
                                
    • 
                                
  • 属性颜色字体变化
                                    周华华
JavaScript
                                    
    function changSize(className){ 
 
 var diva=byId("fot") 
 diva.className=className; 
 } 
</script> 
<style type="text/css"> 
 .max{ 
 background: #900; 
 color:#039; 
 
    
                                
    • 
                                
  • 将properties内容放置到map中
                                    g21121
properties
                                    
    代码比较简单： 
private static Map<Object, Object> map;
private static Properties p;

static {
	//读取properties文件
	InputStream is = XXX.class.getClassLoader().getResourceAsStream("xxx.properti
    
                                
    • 
                                
  • [简单]拼接字符串
                                    53873039oycg
字符串
                                    
             工作中遇到需要从Map里面取值拼接字符串的情况，自己写了个，不是很好，欢迎提出更优雅的写法，代码如下： 
          
import java.util.HashMap;
import java.uti
    
                                
    • 
                                
  • Struts2学习
                                    云端月影

                                    
    最近开始关注struts2的新特性，从这个版本开始，Struts开始使用convention-plugin代替codebehind-plugin来实现struts的零配置。 
配置文件精简了，的确是简便了开发过程，但是，我们熟悉的配置突然disappear了，真是一下很不适应。跟着潮流走吧，看看该怎样来搞定convention-plugin。 
使用Convention插件，你需要将其JAR文件放
    
                                
    • 
                                
  • Java新手入门的30个基本概念二
                                    aijuans
java新手java 入门
                                    
    基本概念:　　1.OOP中唯一关系的是对象的接口是什么,就像计算机的销售商她不管电源内部结构是怎样的,他只关系能否给你提供电就行了,也就是只要知道can or not而不是how and why.所有的程序是由一定的属性和行为对象组成的,不同的对象的访问通过函数调用来完成,对象间所有的交流都是通过方法调用,通过对封装对象数据,很大限度上提高复用率。　　2.OOP中最重要的思想是类,类是模板是蓝图,
    
                                
    • 
                                
  • jedis 简单使用
                                    antlove
javarediscachecommandjedis
                                    
    jedis.RedisOperationCollection.java 
package jedis;

import org.apache.log4j.Logger;
import redis.clients.jedis.Jedis;

import java.util.List;
import java.util.Map;
import java.util.Set;

pub
    
                                
    • 
                                
  • PL/SQL的函数和包体的基础
                                    百合不是茶
PL/SQL编程函数包体显示包的具体数据包
                                    
    由于明天举要上课,所以刚刚将代码敲了一遍PL/SQL的函数和包体的实现(单例模式过几天好好的总结下再发出来);以便明天能更好的学习PL/SQL的循环,今天太累了,所以早点睡觉,明天继续PL/SQL总有一天我会将你永远的记载在心里,,, 
  
函数; 
函数:PL/SQL中的函数相当于java中的方法;函数有返回值
定义函数的
--输入姓名找到该姓名的年薪
create or re
    
                                
    • 
                                
  • Mockito(二)--实例篇
                                    bijian1013
持续集成mockito单元测试
                                    
            学习了基本知识后，就可以实战了，Mockito的实际使用还是比较麻烦的。因为在实际使用中，最常遇到的就是需要模拟第三方类库的行为。 
        比如现在有一个类FTPFileTransfer，实现了向FTP传输文件的功能。这个类中使用了a
    
                                
    • 
                                
  • 精通Oracle10编程SQL(7)编写控制结构
                                    bijian1013
oracle数据库plsql
                                    
    /*
 *编写控制结构
 */
 
--条件分支语句
--简单条件判断
DECLARE
  v_sal NUMBER(6,2);
BEGIN
  select sal into v_sal from emp
  where lower(ename)=lower('&name');
  if v_sal<2000 then
     update emp set
    
                                
    • 
                                
  • 【Log4j二】Log4j属性文件配置详解
                                    bit1129
log4j
                                    
    如下是一个log4j.properties的配置 
  
log4j.rootCategory=INFO, stdout , R

log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appe
    
                                
    • 
                                
  • java集合排序笔记
                                    白糖_
java
                                    
    public class CollectionDemo implements Serializable,Comparable<CollectionDemo>{
	
	private static final long serialVersionUID = -2958090810811192128L;
	
	private int id;
	private String nam
    
                                
    • 
                                
  • java导致linux负载过高的定位方法
                                    ronin47

                                    
    定位java进程ID 
可以使用top或ps -ef |grep java
![图片描述][1]
 根据进程ID找到最消耗资源的java pid 
比如第一步找到的进程ID为5431
执行
top -p 5431 -H
![图片描述][2]
 打印java栈信息 
$ jstack -l 5431 > 5431.log
 在栈信息中定位具体问题 
将消耗资源的Java PID转
    
                                
    • 
                                
  • 给定能随机生成整数1到5的函数，写出能随机生成整数1到7的函数
                                    bylijinnan
函数
                                    
    
import java.util.ArrayList;
import java.util.List;
import java.util.Random;


public class RandNFromRand5 {

	/**
	 题目：给定能随机生成整数1到5的函数，写出能随机生成整数1到7的函数。
	 
	 解法1：
		 f(k) = (x0-1)*5^0+(x1-
    
                                
    • 
                                
  • PL/SQL Developer保存布局
                                    Kai_Ge

                                    
          近日由于项目需要，数据库从DB2迁移到ORCAL，因此数据库连接客户端选择了PL/SQL Developer。由于软件运用不熟悉，造成了很多麻烦，最主要的就是进入后，左边列表有很多选项，自己删除了一些选项卡，布局很满意了，下次进入后又恢复了以前的布局，很是苦恼。在众多PL/SQL Developer使用技巧中找到如下这段： 
  
&n
    
                                
    • 
                                
  • [未来战士计划]超能查派[剧透,慎入]
                                    comsci
计划
                                    
           非常好看,超能查派,这部电影......为我们这些热爱人工智能的工程技术人员提供一些参考意见和思想........ 
 
 
       虽然电影里面的人物形象不是非常的可爱....但是非常的贴近现实生活.... 
 
   &nbs
    
                                
    • 
                                
  • Google Map API V2
                                    dai_lm
google map
                                    
    以后如果要开发包含google map的程序就更麻烦咯 
 
http://www.cnblogs.com/mengdd/archive/2013/01/01/2841390.html 
 
找到篇不错的文章，大家可以参考一下 
 
http://blog.sina.com.cn/s/blog_c2839d410101jahv.html 
 
1. 创建Android工程 
由于v2的key需要G
    
                                
    • 
                                
  • java数据计算层的几种解决方法2
                                    datamachine
javasql集算器
                                    
    2、SQL 
    SQL/SP/JDBC在这里属于一类，这是老牌的数据计算层，性能和灵活性是它的优势。但随着新情况的不断出现，单纯用SQL已经难以满足需求，比如： JAVA开发规模的扩大，数据量的剧增，复杂计算问题的涌现。虽然SQL得高分的指标不多，但都是权重最高的。 
 
    成熟度：5星。最成熟的。 
  
    
                                
    • 
                                
  • Linux下Telnet的安装与运行
                                    dcj3sjt126com
linuxtelnet
                                    
     
Linux下Telnet的安装与运行       linux默认是使用SSH服务的 而不安装telnet服务    如果要使用telnet 就必须先安装相应的软件包    即使安装了软件包 默认的设置telnet 服务也是不运行的 需要手工进行设置   如果是redhat9，则在第三张光盘中找到   telnet-server-0.17-25.i386.rpm  
    
                                
    • 
                                
  • PHP中钩子函数的实现与认识
                                    dcj3sjt126com
PHP
                                    
    假如有这么一段程序： 
 
 function fun(){ 
  fun1(); 
  fun2(); 
 } 
 
  首先程序执行完fun1()之后执行fun2()然后fun()结束。 
  但是，假如我们想对函数做一些变化。比如说，fun是一个解析函数，我们希望后期可以提供丰富的解析函数，而究竟用哪个函数解析，我们希望在配置文件中配置。这个时候就可以发挥钩子的力量了。 
  我们可以在fu
    
                                
    • 
                                
  • EOS中的WorkSpace密码修改
                                    蕃薯耀
修改WorkSpace密码
                                    
    EOS中BPS的WorkSpace密码修改 
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 
蕃薯耀 201
    
                                
    • 
                                
  • SpringMVC4零配置--SpringSecurity相关配置【SpringSecurityConfig】
                                    hanqunfeng
SpringSecurity
                                    
     SpringSecurity的配置相对来说有些复杂，如果是完整的bean配置，则需要配置大量的bean，所以xml配置时使用了命名空间来简化配置，同样，spring为我们提供了一个抽象类WebSecurityConfigurerAdapter和一个注解@EnableWebMvcSecurity，达到同样减少bean配置的目的，如下： 
  
applicationContex
    
                                
    • 
                                
  • ie 9 kendo ui中ajax跨域的问题
                                    jackyrong
AJAX跨域
                                    
    这两天遇到个问题，kendo ui的datagrid，根据json去读取数据，然后前端通过kendo ui的datagrid去渲染，但很奇怪的是，在ie 10,ie 11,chrome,firefox等浏览器中，同样的程序， 
浏览起来是没问题的，但把应用放到公网上的一台服务器， 
却发现如下情况： 
 
 
1） ie 9下，不能出现任何数据，但用IE 9浏览器浏览本机的应用，却没任何问题 
 
    
                                
    • 
                                
  • 不要让别人笑你不能成为程序员
                                    lampcy
编程程序员
                                    
    在经历六个月的编程集训之后，我刚刚完成了我的第一次一对一的编码评估。但是事情并没有如我所想的那般顺利。 
说实话，我感觉我的脑细胞像被轰炸过一样。 
手慢慢地离开键盘，心里很压抑。不禁默默祈祷：一切都会进展顺利的，对吧？至少有些地方我的回答应该是没有遗漏的，是不是？ 
难道我选择编程真的是一个巨大的错误吗——我真的永远也成不了程序员吗？ 
我需要一点点安慰。在自我怀疑，不安全感和脆弱等等像龙卷风一
    
                                
    • 
                                
  • 马皇后的贤德
                                    nannan408

                                    
       马皇后不怕朱元璋的坏脾气，并敢理直气壮地吹耳边风。众所周知，朱元璋不喜欢女人干政，他认为“后妃虽母仪天下，然不可使干政事”，因为“宠之太过，则骄恣犯分，上下失序”，因此还特地命人纂述《女诫》，以示警诫。但马皇后是个例外。 
 
　　有一次，马皇后问朱元璋道：“如今天下老百姓安居乐业了吗？”朱元璋不高兴地回答：“这不是你应该问的。”马皇后振振有词地回敬道：“陛下是天下之父，
    
                                
    • 
                                
  • 选择某个属性值最大的那条记录（不仅仅包含指定属性，而是想要什么属性都可以）
                                    Rainbow702
sqlgroup by最大值max最大的那条记录
                                    
    好久好久不写SQL了，技能退化严重啊！！！ 
  
直入主题： 
比如我有一张表，file_info， 
它有两个属性（但实际不只，我这里只是作说明用）： 
file_code, file_version 
同一个code可能对应多个version 
现在，我想针对每一个code，取得它相关的记录中，version 值 最大的那条记录， 
SQL如下： 
select 
    *

    
                                
    • 
                                
  • VBScript脚本语言
                                    tntxia
VBScript
                                    
      
VBScript 是基于VB的脚本语言。主要用于Asp和Excel的编程。 
  VB家族语言简介 
  
 
 Visual Basic 6.0 
 
          源于BASIC语言。 
          由微软公司开发的包含协助开发环境的事
    
                                
    • 
                                
  • java中枚举类型的使用
                                    xiao1zhao2
javaenum枚举1.5新特性
                                    
    枚举类型是j2se在1.5引入的新的类型,通过关键字enum来定义,常用来存储一些常量. 
  1.定义一个简单的枚举类型 
public enum Sex {
	MAN,
	WOMAN
} 
  
枚举类型本质是类,编译此段代码会生成.class文件.通过Sex.MAN来访问Sex中的成员,其返回值是Sex类型. 
  2.常用方法 
静态的values()方
    
                                
    •