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

2.CSharp列表相关

字典遍历

通过for ... in ...:的语法结构,我们可以遍历字符串、列表、元组、字典等数据结构。

遍历字典的key

>>> info={'name':'Tom','age':12}
>>> for key in info.keys():
...     print(key)
...
name
age

遍历字典的value

>>> info={'name':'Tom','age':12}
>>> for value in info.values():
...     print(value)
...
Tom
12

遍历字典的项

>>> info={'name':'Tom','age':12}
>>> for item in info.items():
...     print(item)
...
('name', 'Tom')
('age', 12)

遍历字典的key-value

>>> info={'name':'Tom','age':12}
>>> for key,value in info.items():
...     print("key=%s,value=%s"%(key,value))
...
key=name,value=Tom
key=age,value=12

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

元组

Python的元组与列表类似,不同之处在于元组的元素不能修改。元组使用小括号,列表使用方括号。

示例:

>>> aTuple = ('et',77,99.9)
>>> aTuple
('et',77,99.9)

访问元组

>>> tuple = ('hello',100,3.14)
>>> tuple[0]
'hello'
>>> tuple[1]
100
>>> tuple[2]
3.14

修改元组

>>> tuple[2] = 10
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

元组的内置函数count, index
index和count与字符串和列表中的用法相同。

>>> a = ('a', 'b', 'c', 'a', 'b')
>>> a.index('a', 1, 3) # 注意是左闭右开区间
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: tuple.index(x): x not in tuple
>>> a.index('a', 1, 4)
3
>>> a.count('b')
2
>>> a.count('d')
0

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

 

字典的常见操作

添加元素
访问不存在的键,则会报错。

>>> info={'name':'Tom','age':12}
>>> print('id is %d'%info['id'])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'id'

如果在使用 变量名['键'] = 数据 时,这个“键”在字典中,不存在,那么就会新增这个元素。

>>> info={'name':'Tom','age':12}
>>> info['id']=1
>>> print(info)
{'name': 'Tom', 'age': 12, 'id': 1}

删除元素

  • del:删除指定的元素、整个字典,删完整个字典后不能访问
  • clear():清空整个字典,清空完可以访问

示例:

>>> del info['age']
>>> print(info)
{'name': 'Tom', 'id': 1}
>>> del info
>>> print(info)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'info' is not defined

>>> info={'name':'Tom','age':12}
>>> info.clear()
>>> print(info)
{}

修改元素
字典的每个元素中的数据是可以修改的,只要通过key找到,即可修改。

info = {'name':'班长', 'id':100, 'sex':'f', 'address':'地球亚洲中国北京'}
newId = 200
info['id'] = newId
print('修改之后的id为%d:'%info['id'])

常用函数

  • len():测量字典中,键值对的个数
  • keys():返回一个包含字典所有KEY的列表
  • values():返回一个包含字典所有value的列表
  • items():返回一个包含所有(键,值)元祖的列表
  • has_key:dict.has_key(key)如果key在字典中,返回True,否则返回False(2.7版本)
  • in:key in dict(3.6版本)

示例:

>>> info={'name':'Tom','age':12}
>>> len(info)
2
>>> info.keys()
dict_keys(['name', 'age'])
>>> info.values()
dict_values(['Tom', 12])
>>> info.items()
dict_items([('name', 'Tom'), ('age', 12)])
>>> 'name' in info
True

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);

 

列表的相关操作

添加元素

  • append:通过append可以向列表添加元素
  • extend:通过extend可以将另一个集合中的元素逐一添加到列表中
  • insert:insert(index, object)在指定位置index前插入元素object

示例:

>>> a = [1, 2]
>>> b = [3, 4]
>>> a.append(b)
>>> a
[1, 2, [3, 4]]
>>> a.extend(b)
>>> a
[1, 2, [3, 4], 3, 4]
>>> a.insert(1, 3)
>>> a
[1, 3, 2, [3, 4], 3, 4]

删除元素

  • del:根据下标进行删除
  • pop:删除最后一个元素
  • remove:根据元素的值进行删除

示例:

movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情']
for tempName in movieName:
    print(tempName)

del movieName[2]
for tempName in movieName:
    print(tempName)

movieName.pop()
for tempName in movieName:
    print(tempName)

movieName.remove('指环王')
for tempName in movieName:
    print(tempName)

运行结果:

加勒比海盗
骇客帝国
第一滴血
指环王
霍比特人
速度与激情

加勒比海盗
骇客帝国
指环王
霍比特人
速度与激情

加勒比海盗
骇客帝国
指环王
霍比特人

加勒比海盗
骇客帝国
霍比特人

修改元素
修改元素的时候,要通过下标来确定要修改的是哪个元素,然后才能进行修改。

#定义变量A,默认有3个元素
A = ['xiaoWang','xiaoZhang','xiaoHua']

for tempName in A:
    print(tempName)

#修改元素
A[1] = 'xiaoLu'

for tempName in A:
    print(tempName)

运行结果:

xiaoWang
xiaoZhang
xiaoHua

xiaoWang
xiaoLu
xiaoHua

查找元素
所谓的查找,就是看看指定的元素是否存在。

  • in(存在),如果存在那么结果为true,否则为false。
  • not in(不存在),如果不存在那么结果为true,否则false。

示例:

#待查找的列表
nameList = ['xiaoWang','xiaoZhang','xiaoHua']

#获取用户要查找的名字
findName = input('请输入要查找的姓名:')

#查找是否存在
if findName in nameList:
    print('在字典中找到了相同的名字')
else:
    print('没有找到')

index和count与字符串中的用法相同。

>>> a = ['a', 'b', 'c', 'a', 'b']
>>> a.index('a', 1, 3) # 注意是左闭右开区间
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: 'a' is not in list
>>> a.index('a', 1, 4)
3
>>> a.count('b')
2
>>> a.count('d')
0

排序

  • sort方法是将list按特定顺序重新排列,默认为由小到大,参数reverse=True可改为倒序,由大到小。
  • reverse方法是将list逆置。

示例:

>>> a = [1, 4, 2, 3]
>>> a
[1, 4, 2, 3]
>>> a.reverse()
>>> a
[3, 2, 4, 1]
>>> a.sort()
>>> a
[1, 2, 3, 4]
>>> a.sort(reverse=True)
>>> a
[4, 3, 2, 1]

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]

 

列表的循环遍历

使用for循环

namesList = ['xiaoWang','xiaoZhang','xiaoHua']
for name in namesList:
    print(name)

运行结果:

xiaoWang
xiaoZhang
xiaoHua

使用while循环

namesList = ['xiaoWang','xiaoZhang','xiaoHua']
length = len(namesList)
i = 0
while i<length:
    print(namesList[i])
    i+=1

运行结果:

xiaoWang
xiaoZhang
xiaoHua

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'

 

列表的嵌套

列表嵌套
类似while循环的嵌套,列表也是支持嵌套的。一个列表中的元素又是一个列表,那么这就是列表的嵌套。

schoolNames = [['北京大学','清华大学'],
                ['南开大学','天津大学','天津师范大学'],
                ['山东大学','中国海洋大学']]

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]:

'萌萌哒'

 

列表介绍

列表的格式
变量namesList的类型为列表,不同于C语言,列表元素可以使不同类型;

namesList = ['xiaoWang','xiaoZhang','xiaoHua',1,2,3]

打印列表

namesList = ['xiaoWang','xiaoZhang','xiaoHua']
print(namesList[0])
print(namesList[1])
print(namesList[2])

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.数组系列

 

字典

类似Json数据键值对格式。

  • 字典和列表一样,也能够存储多个数据
  • 列表中找某个元素时,是根据下标进行的
  • 字典中找某个元素时,是根据'名字'(就是冒号:前面的那个值,例如上面代码中的'name'、'id'、'sex')
  • 字典的每个元素由2部分组成,键:值。例如 'name':'班长' ,'name'为键,'班长'为值

根据键访问值

info = {'name':'班长', 'id':100, 'sex':'f', 'address':'地球亚洲中国北京'}

print(info['name'])
print(info['address'])

结果:

班长
地球亚洲中国北京

注:若访问不存在的键,则会报错。

>>> info['age']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'age'

在我们不确定字典中是否存在某个键而又想获取其值时,可以使用get方法,还可以设置默认值。

>>> age = info.get('age')
>>> age #'age'键不存在,所以age为None
>>> type(age)
<type 'NoneType'>
>>> age = info.get('age', 18) # 若info中不存在'age'这个键,就返回默认值18
>>> age
18

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

 

补充概念strtuple 也可以用切片操作哦~

str上次说了,这次说下Tuple(后面会继续说Tuple,先了解下吧)

In [47]:

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

Out[47]:

(1, 2)

 

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

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监视信息)

金沙官网线上 1

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

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

金沙官网线上 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)

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

 

2.5.列表查询

IndexOfCount 这两个讲过了

查找用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

 

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)]

 

8.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
加息
加息

 

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.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在比较字典数据时,先比较键,再比较值

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

5.Python字典系列

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

 

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}");
}

 

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,则可以在面对这样情况的时候灵活应对。

 

本文由金沙官网线上发布于操作系统,转载请注明出处:Python3 与 C# 基础语法对比(List、Tuple、Dict、Set专

您可能还会对下面的文章感兴趣: