澳门在线威尼斯官方 > 电脑操作 > 基础语法对比

原标题:基础语法对比

浏览次数:141 时间:2019-11-10

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") # 没有返回值

 

字典的普及操作

添欧成分
访谈海市蜃楼的键,则会报错。

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

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'

 

元组

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

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

 

列表介绍

列表的格式
变量namesList的等级次序为列表,不一致于C语言,列表成分能够使区别档期的顺序;

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

打字与印刷列表

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

4.CSharp元组相关¶

逆天ValueTuple用的超级多,上边案例便是用的这些

元组系:

值元组:

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)

就聊到那了,简单询问就可以

 

列表的嵌套

列表嵌套
相符while循环的嵌套,列表也是扶助嵌套的。三个列表中的成分又是叁个列表,那么那便是列表的嵌套。

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

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

列表的连锁操作

添美金素

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

先戏弄一下:Python面向对象真心必要正统,不然太轻易走火入魔了 -_-!!! 汗,后一次再说。。。

列表的大循环遍历

使用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

1.1.列表定义、遍历¶

info_list=[] #空列表

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

遍历和事先同生龙活虎,for 或者 while 都可以

for扩展:

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

 

字典

贴近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

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

 

字典遍历

透过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

几天前说说List、Tuple、Dict、Set。POP部分还会有点如Func、IO(也能够放OOP部分说卡塔 尔(阿拉伯语:قطر‎然后就说说面向对象吧。

Code:

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

'萌萌哒'

 

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.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

 

1.Python列表相关¶

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]

 

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.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.CSharp列表相关¶

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'})

 

7.集合Set¶

在线预览

本文由澳门在线威尼斯官方发布于电脑操作,转载请注明出处:基础语法对比

关键词:

上一篇:最简化搭建yum货仓

下一篇:没有了