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

最新推荐文章于 2021-05-18 22:45:37 发布
最新推荐文章于 2021-05-18 22:45:37 发布
阅读量486 收藏
点赞数
文章标签： python c# javascript ViewUI
原文链接：http://www.cnblogs.com/dotnetcrazy/p/9155310.html
版权
 

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<object>
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)
<ipython-input-13-ad52d76f39b4> in <module>()
      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)
<ipython-input-15-9f9cdd692e63> in <module>()
----> 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)
<ipython-input-17-b6366d96a6e9> in <module>()
----> 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)
<ipython-input-19-7de289d35755> in <module>()
----> 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)
<ipython-input-22-ecf5fb72864d> in <module>()
----> 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)
<ipython-input-24-6c57bb050f66> in <module>()
----> 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<object>() { "C#", "JavaScript" };

遍历可以用foreach，for，while

In [60]: 
%%script csharp
//# 定义一个列表
// # infos_list=["C#","JavaScript"]#[]
var infos_list = new List<object>() { "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<len(infos_list):
// #     print(infos_list[i])
// #     i+=1
int j=0;
while(j<infos_list.Count){
   Console.WriteLine(infos_list[j++]);
}
  
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<object>            
// # 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<string>(){"张三","李四","王二麻子"};
// 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<object>() { 33, 44, 22,new List<object>(){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))
  
<class 'tuple'>
<class 'int'>
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)
<ipython-input-64-293cf803dc90> in <module>()
      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监视信息）

图片

// 初始化
var test_tuple = ("萌萌哒", 1, 3, 5, "加息", "加息"); //这种方式就是valueTuple了
test_tuple.Item1 = "ddd";//可以修改值
test_tuple.GetType();

需要说下的是，取值只能通过itemxxx来取了，然后就是valueTuple的值是可以修改的

图片

下面直接进入应用场景：

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)
<ipython-input-86-f185376d67c2> in <module>()
      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)
<ipython-input-87-3f776e9bf984> in <module>()
      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)
<ipython-input-90-dc5eeda55ffa> in <module>()
----> 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)
<ipython-input-92-2a26e199752e> in <module>()
----> 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)
<ipython-input-97-bc0a122c60bb> in <module>()
----> 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<value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __or__(self, value, /)
 |      Return self|value.
 |  
 |  __rand__(self, value, /)
 |      Return value&self.
 |  
 |  __reduce__(...)
 |      Return state information for pickling.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __ror__(self, value, /)
 |      Return value|self.
 |  
 |  __rsub__(self, value, /)
 |      Return value-self.
 |  
 |  __rxor__(self, value, /)
 |      Return value^self.
 |  
 |  __sizeof__(...)
 |      S.__sizeof__() -> 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)
<ipython-input-115-1d51a9949e6e> in <module>()
      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)
<ipython-input-149-7da4501a78c2> in <module>()
      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

LP890127
关注
Python学习，python中的list,tuple,dict和set
sehun_sx的博客
04-03 952
List list的创建与检索 Python内置的一种数据类型是列表：list。list是一种有序的集合，可以随时添加和删除其中的元素。 构造list非常简单，直接用 [ ] 把list的所有元素都括起来，就是一个list对象。 Python是动态语言，所以list中包含的元素并不要求都必须是同一种数据类型，我们完全可以在list中包含各种数据： 例如： >>> L = ['Michael', 100, True] list索引从 0 开始，也就是说，第一个元素的索引是0，第二个元素的索
python中的list、tuple、dict、set
陌生
09-24 780
文章目录前言一、python中的list二、python中的tuple三、python中的dict四、python中的set总结 前言 python中的list、tuple、dict、set的区别 提示：以下是本篇文章正文内容，下面案例可供参考 一、python中的list （1）构造list，使用[ ]把list的所有元素都括起来就是一个列表，用变量L表示。其中的元素不要求是同一种数据类型。 （2）列表中元素是有序的。可以通过索引来访问。 （3）访问list的元素，L[0]：表示列表中的第一个元素，
C#中Dictionary的用法及用途实例
03-09
C#中Dictionary的用法及用途实例 魔鬼作坊学游戏辅助制作 moguizuofang.com
c#和python_C#学习笔记（与Java、C、C++和Python对比）
weixin_39926311的博客
11-24 132
最近准备学习一下Unity3D，在C#和JavaScript中选择了C#。所以，作为学习Unity3D的准备工作，首先需要学习一下C#。用了一两天的时间学了一下C#，感觉是处在C++和Java之间的一门语言。比Java更灵活，比C++更简单，确实是一门设计很优秀的语言。基础概念和语法基本数据类型C#中的基本数据类型分为值类型和引用类型。相比Java而言，增加了无符号数，多了C中的struct，字符...
用python模仿c#的List<>一组list筛选扩展方法
weixin_34075268的博客
12-28 125
2019独角兽企业重金招聘Python工程师标准>>> ...
Python脚本调用C#代码数据交互示例（hello world）
weixin_33953384的博客
08-09 426
原地址： http://www.djangochina.cn/forum.php?mod=viewthread&amp;tid=247  随着项目的逐渐收尾， 对IronPython脚本也越来越熟悉，这里为IronPython脚本感兴趣但不入门的朋友写几篇使用心得，这是第一个：最简单的hello world程序。        首先，我们必须有一个IronPython脚本引擎库（IronPyt...
C# list集合 重复元素 索引_Python基础篇 -3：初识Python中的整数、浮点数、字符串、列表、元组、集合和字典...
weixin_39587407的博客
11-20 174
Python学习基础篇 -3前言：本专栏以Python为主题，并尽可能保持每星期两到三更，直到将Python的基础知识浅析和讲解完毕，同时，有一定基础的同学可以移步 Python实战专栏 。第三篇：初识Python中的整数、浮点数、字符串、列表、元组、集合和字典Python中的整数和浮点数类型的变量简而言之，整数就是 -1 0 1等数字，浮点数就是 1.2 和-0.8等带有小数点的数字。这些数字类...
Python中内置数据类型list,tuple,dict,set的区别和用法
01-20
这其中Python的四个内置数据类型功不可没，他们即是list, tuple, dict, set。这里对他们进行一个简明的总结。 List 字面意思就是一个集合，在Python中List中的元素用中括号[]来表示，可以这样定义一个List: L = [12...
python的dict,set,list,tuple应用详解
12-24
本文深入剖析了python中dict,set,list,tuple应用及对应示例，有助于读者对其概念及原理的掌握。具体如下： 1.字典(dict) dict 用 {} 包围 dict.keys(),dict.values(),dict.items() hash(obj)返回obj的哈希值，如果...
python中的list、tuple、set、dict用法简析.doc
09-15
Python 中的 List、Tuple、Set、Dict 用法简析 Python 是一种高级的编程语言，它提供了多种数据结构，包括列表（List）、元组（Tuple）、集合（Set）和字典（Dict）。这些数据结构可以用来存储和处理数据，本文将...
Python 和C#的交互
45°仰望星空
08-11 7972
https://blog.csdn.net/henu_xk126com   IronPython和C#交互   IronPython是一个.NET平台上的Python实现，包括了完整的编译器、执行引擎与运行时支持，能够与.NET已有的库无缝整合到一起。 IronPython已经很好的集成到了.NET framework中，所以Ironpython和C#的交互也就变得很简单了。下面就通过一...
python 如何传递字典型变量（不定参数）给c++
测试开发这些事
04-29 217
今天遇到一个难题，python要调用c++一个函数 c++函数是可变长的变量如add(int cmd,...) 然后再c++中使用va_list取得变长参数。 那么python 该如何调用该函数呢。弄了半天也没有发现boost.python如何支持该类型的参数。 后来一想，python dict不是就是可变长的参数吗，里边放什么都可以。 那么问题就转化问如何传递dict给c++。 贴源...
C# list集合 重复元素 索引_Python列表（List）
weixin_39789101的博客
11-09 533
列表(Lists)就像用其他语言声明的数组一样。列表不一定总是同质的，这使其成为Python中最强大的工具。单个列表可能包含数据类型，例如整数，字符串以及对象。列表是可变的，因此即使在创建后也可以对其进行更改。Python中的List是有序的，并且有一个确定的计数。列表中的元素按照一定的顺序进行索引，并且列表的索引是在0为第一个索引的情况下完成的。列表中的每个元素在列表中都有其明确的位置，这允许复...
Tuple（元组）与Dictionary（字典）
Hello World
09-14 1693
Tuple（元组）与Dictionary（字典）元组Dictionary（字典） 元组 元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。 元组中的元素类型也可以不相同： 示例： #!/usr/bin/python3 tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2 ) tinytuple = (123, 'runoob') print (tuple) # 输出完整元组 print
python给c语言传递参数,【python-C相互调用】python里的dict如何作为参数传入.so中的c语言函数...
weixin_32558831的博客
05-18 450
用户提问【python-C相互调用】关于python通过.so调用C函数来读取python里某个key的值并进行处理，一直无法将dict传到C中，求助1. 首先是C中的包装函数定义static PyObject *Extest_reverse(PyObject *self, PyObject *args,PyObject *keyds){//PyObject* keyds = PyDict_Key...
004--从C#到Python —— 1 变量和数据类型
11-13 920
<br />“一切数据是对象，一切命名是引用 ”。<br />如果你能理解这句话，说明对Python的变量与数据类型已经有了不错的认识，那么我建议你直接跳到1.4节的总结部分，看看C#与Python在变量与数据类型方面的差异就可以。如果你还有疑惑，那么就请完整的读一下这一章吧。<br />好，让我们开始。1.1 变量声明和定义1.1.1  变量声明和定义<br />与C#不同，Python在使用变量之前无须定义它的类型 ，试着运行下面的例子：1i =1<br />2 print i<br />从上边我们
c# 字典排序_Python有序字典的两个小“惊喜”~~
weixin_39997089的博客
11-03 157
点击上方“AI算法与图像处理”，选择加"星标"或“置顶”重磅干货，第一时间送达英文：Ordered dict surprises(https://nedbatchelder.com//blog/202010/ordered_dict_surprises.html)作者：Ned Batchelder译者：豌豆花下猫来源：Python猫从 Python 3.6 开始，常规的字典会记住其插入...
C#关于NameValueCollection，Dictionary,List Tuple比较
ylq1045的专栏
05-28 1695
我们在开发项目，根据实际需要，选择最适合的数据类型。存在即合理 NameValueCollection、Dictionary<string,string>,List<Tuple<string,string>>三个类都可以表示键值对集合。 但根据使用场景的不同，建议选择不同的类型来进行相应的处理。 NameValueCollection用于键名不区分大小写，比如读取（或写入）ini文件，键名是不区分大小写的。nvc[键名]不存在将返回null，并不抛出异常 Dict
dictionary (字典)、tuple (元组) 和 list (列表)
12-20 284
dictionaryd = {"server":"mpilgrim", "database":"master"} print d["server"] print dd["database"] = "pubs" d["uid"] = "sa"    del d["server"]  d.clear()在一个 dictionary 中不能有重复的 k
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值