将元组转换为 int - python（将元组转换为列表）

25-04-21 9

对于想了解将元组转换为int-python的读者，本文将提供新的信息，我们将详细介绍将元组转换为列表，并且为您提供关于(int)、int.Parse()、int.TryParse()、Convert.

对于想了解将元组转换为 int - python的读者，本文将提供新的信息，我们将详细介绍将元组转换为列表，并且为您提供关于(int)、int.Parse()、int.TryParse()、Convert.ToInt32()区别、/编写一个函数，要求从给定的向量A中删除元素值在x到y之间的所有元素(向量要求各个元素之间不能有间断)，函数原型为int del(int A ,int n , int x , int y),其...、2022-03-11：int n, int[][] roads, int x, int y， n表示城市数量，城市编号0~n-1， roads[i][j] == distance，表示城市i到城市j距、2022-05-26：void add(int L, int R, int C)代表在arr[L...R]上每个数加C， int get(int L, int R)代表查询arr[L...R]上的累加的有价值信息。

本文目录一览：

将元组转换为 int - python（将元组转换为列表）
(int)、int.Parse()、int.TryParse()、Convert.ToInt32()区别
/编写一个函数，要求从给定的向量A中删除元素值在x到y之间的所有元素(向量要求各个元素之间不能有间断)，函数原型为int del(int A ,int n , int x , int y),其...
2022-03-11：int n, int[][] roads, int x, int y， n表示城市数量，城市编号0~n-1， roads[i][j] == distance，表示城市i到城市j距
2022-05-26：void add(int L, int R, int C)代表在arr[L...R]上每个数加C， int get(int L, int R)代表查询arr[L...R]上的累加

将元组转换为 int - python（将元组转换为列表）

如何解决将元组转换为 int - python

我有下表（df）：

形状	数据
多边形	((1280 16068.18,1294 16059,1297 16060,1300 16063,1303 16065,1308 16066))
要点	点 ((37916311947 12769))
多边形	多边形 ((1906.23 12983,1908 12982,1916 12974,1917 12972,1917 12970))

我想将表格转换为以下格式：

所需的输出：

converted_data
[(1280,16068),(1294,16059),(1297,16060),(1300,16063),(1303,16065),(1308,16066)]
[(37916311947,12769)]
[(1906,12983),(1908,12982),(1916,12974),(1917,12972),12970)]

我想修改括号并添加逗号并删除单词 polyGON 或 POINT。到目前为止我尝试了什么？

res1 = []
for ip,geom in zip(df2[''data''],df2[''SHAPE'']):
    if geom == ''POINT'':
        st = str(ip)[8:-2]
    elif geom == ''polyGON/SURFACE'':
        st = str(ip)[10:-2]
    s = st.split('','')
    res1.append(s)
res = []
for i in res1:
    res.append([tuple(map(int,j.split())) for j in i])
data2 = df2.copy()
data2[''converted_data'']=res
´´´
The above script works saves the output as tuple and not int. How do I optimize my script?

解决方法

您的代码的第一部分看起来不错 - 在第二部分您可能试图拆分 i 而不是 j

x = ''1280 16068.18,1294 16059,1297 16060,1300 16063,1303 16065,1308 16066''
x_split = [tuple(map(lambda x: int(float(x)),i.strip().split())) for i in x.strip().split('','')] 
#[(1280,16068),# (1294,16059),# (1297,16060),# (1300,16063),# (1303,16065),# (1308,16066)]

df = pd.DataFrame([[''POLYGON'',''((1280 16068.18,1308 16066))''],[''POINT'',''POINT ((37916311947 12769))''],[''POLYGON'',''POLYGON ((1906.23 12983,1908 12982,1916 12974,1917 12972,1917 12970))'']],columns=[''shape'',''data''])
df[''data''] = df[''data''].str.findall(r''(\\d[\\d.\\s]+\\d)'').apply(lambda x: [tuple(map(float,i.split())) for i in x])
df

shape   data
0   POLYGON [(1280.0,16068.18),(1294.0,16059.0),(1297....
1   POINT   [(37916311947.0,12769.0)]
2   POLYGON [(1906.23,12983.0),(1908.0,12982.0),(1916....

一种方法是将 str.extractall 与您想要的正则表达式模式一起使用：

print (df["data"].str.extractall("((\\d*[.])?\\d+\\s(\\d*[.])?\\d+)")[0]
                 .str.split(expand=True)
                 .astype(float)
                 .agg(tuple,axis=1)
                 .groupby(level=0).agg(list))
0    [(1280.0,(1297....
1                           [(37916311947.0,12769.0)]
2    [(1906.23,(1916....
dtype: object

(int)、int.Parse()、int.TryParse()、Convert.ToInt32()区别

请看代码：

//1、null。
//int i1 = (int)null;//编译时报错：无法将“null”转换为“int”，因为后者是不可以为“null”的值类型。
//int i2 = int.Parse(null);//执行时报错：“System.ArgumentNullException”，值不能为 null。
//int i3;
//bool b1 = int.TryParse(null, out i3);//b1 = False，i3 = 0。
//int i4 = Convert.ToInt32(null);//i4 = 0。

//2、""。
//string s1 = "";
//int i1 = (int)s1;//编译时报错：无法将“string”装换为“int”。
//int i2 = int.Parse(s1);//执行时报错：“System.FormatException”，输入字符串的格式不正确。 
//int i3;
//bool b1 = int.TryParse(s1, out i3);//b1 = False，i3 = 0。
//int i4 = Convert.ToInt32(s1);//执行时报错：“System.FormatException”，输入字符串的格式不正确。 

//3、小数。
//double d1 = 1.2D;
//double d2 = 1.5D;
//double d3 = 1.8D;
//int i1 = (int)d1;//i1 = 1\1\1。
//int i2 = int.Parse(d1.ToString());//执行时报错：“System.FormatException”，输入字符串的格式不正确。
//int i3;
//bool b1 = int.TryParse(d1.ToString(), out i3);//b1 = False，i3 = 0。
//int i4 = Convert.ToInt32(d3);//i4 = 1\2\2

//4、整数。
//byte b1 = 10;
//int i1 = (int)b1;//i1 = 10。
//int i2 = int.Parse(b1.ToString());//i2 = 10。
//int i3;
//bool b2 = int.TryParse(b1.ToString(), out i3);//b2 = True，i3 = 10。
//int i4 = Convert.ToInt32(b1);//i4 = 10。

总结如下：

(int)数字类型：整型取整，小数取整（不存在四舍五入），其他类型异常。

int.Parse(整型.ToString())：整型.ToString()取整，其他类型异常。

int.TryParse(整型.ToString(), out int i)：整型.ToString()取整，返回True，其他类型返回0，返回False。

Convert.ToInt32(多种类型)：数字类型.ToString()取整，null取0，其他类型异常。其中，如果值是两个数字中间的小数，返回二者中的偶数，其余正常四舍五入，比如3.4返回3，3.5返回4,3.6返回4。Convert.ToInt32()首先判断值是否为null，如果值为null，返回0。

以上是我对(int)、int.Parse()、int.TryParse()、Convert.ToInt32()的理解，希望可以给需要的朋友带来帮助。

/编写一个函数，要求从给定的向量A中删除元素值在x到y之间的所有元素(向量要求各个元素之间不能有间断)，函数原型为int del(int A ,int n , int x , int y),其...

/编写一个函数，要求从给定的向量A中删除元素值在x到y之间的所有元素(向量要求各个元素之间不能有间断)，函数原型为int del(int A ,int n , int x , int y),其...

/**
 * @author：（LiberHome）
 * @date：Created in 2019/2/28 19:39
 * @description：
 * @version:$
 */
/* 编写一个函数，要求从给定的向量A中删除元素值在x到y之间的所有元素(向量要求各个元素之间不能有间断)，
函数原型为int del(int A ,int n , int x , int y),其中n为输入向量的维数，返回值为删除元素后的维数*/

public class page0602 {
    public static void main(String[] args) {
        int[] A={1,2,3,4,5,6,7,8,9,10};
        int result=-1;
        int x=3;
        int y=5;
        result=del(A,A.length,x,y);
    }

    private static int del(int[] arr, int len, int a, int b) {
        int i=a;
        int j=b+1;
        while (j+1<len){
            arr[i]=arr[j];
        }
        return len-(b+1-a);
    }


}

2022-03-11：int n, int[][] roads, int x, int y， n表示城市数量，城市编号0~n-1， roads[i][j] == distance，表示城市i到城市j距

2022-03-11：int n, int[][] roads, int x, int y， n表示城市数量，城市编号0~n-1， roads[i][j] == distance，表示城市i到城市j距离为distance(无向图)，求城市x到城市y的最短距离。

答案2022-03-11：

有向图，没有负数环。小根堆。

代码用golang编写。代码如下：

package main

import (
	"fmt"
	"math"
	"sort"
)

func main() {
	roads := [][]int{{1, 2, 3}, {1, 3, 5}, {2, 3, 1}}
	n := 3
	x := 1
	y := 3
	ret := minDistance2(n, roads, x, y)
	fmt.Println(ret)
}

func minDistance2(n int, roads [][]int, x, y int) int {
	// 第一步生成邻接矩阵
	map0 := make([][]int, n+1)
	for i := 0; i < n+1; i++ {
		map0[i] = make([]int, n+1)
	}
	for i := 0; i <= n; i++ {
		for j := 0; j <= n; j++ {
			map0[i][j] = math.MaxInt64
		}
	}
	// 建立路！
	for _, road := range roads {
		map0[road[0]][road[1]] = getMin(map0[road[0]][road[1]], road[2])
		map0[road[1]][road[0]] = getMin(map0[road[1]][road[0]], road[2])
	}
	// computed[i] = true，表示从源出发点到i这个城市，已经计算出最短距离了
	// computed[i] = false，表示从源出发点到i这个城市，还没有计算出最短距离
	computed := make([]bool, n+1)
	// 距离小根堆
	//PriorityQueue<Node> heap = new PriorityQueue<>((a, b) -> (a.pathSum - b.pathSum));
	heap0 := make([]*Node, 0)
	heap0 = append(heap0, NewNode(x, 0))
	for len(heap0) > 0 {
		// x -> ... -> 当前的城市, 有距离
		sort.Slice(heap0, func(i, j int) bool {
			a := heap0[i]
			b := heap0[j]
			return a.pathSum < b.pathSum
		})
		cur := heap0[0]
		heap0 = heap0[1:]
		if computed[cur.city] {
			continue
		}
		// 没算过
		// 开始算！
		if cur.city == y {
			return cur.pathSum
		}
		computed[cur.city] = true
		for next := 1; next <= n; next++ {
			if next != cur.city && map0[cur.city][next] != math.MaxInt64 && !computed[next] {
				heap0 = append(heap0, NewNode(next, cur.pathSum+map0[cur.city][next]))
			}
		}
	}
	return math.MaxInt64
}

func getMin(a, b int) int {
	if a < b {
		return a
	} else {
		return b
	}
}

// 当前来到的Node，注意这不是城市的意思，这是就是一个普通的封装类
// Node封装了，当前来到的城市是什么，以及，从源出发点到这个城市的路径和是多少？
type Node struct {
	// 当前来到的城市编号
	city int
	// 从源出发点到这个城市的路径和
	pathSum int
}

func NewNode(c, p int) *Node {
	ans := &Node{}
	ans.city = c
	ans.pathSum = p
	return ans

}

执行结果如下：在这里插入图片描述

左神java代码

2022-05-26：void add(int L, int R, int C)代表在arr[L...R]上每个数加C， int get(int L, int R)代表查询arr[L...R]上的累加

2022-05-26：void add(int L, int R, int C)代表在arr[L...R]上每个数加C， int get(int L, int R)代表查询arr[L...R]上的累加和，假设你可以在所有操作开始之前，重新排列arr。请返回每一次get查询的结果都加在一起最大能是多少。输入参数: int[] arr : 原始数组， int[][] ops，二维数组每一行解释如下: [a,b,c]，如果数组有3个数，表示调用add(a,b,c)， [a,b]，如果数组有2个数，表示调用get(a,b)， a和b表示arr范围，范围假设从1开始，不从0开始。输出：假设你可以在开始时重新排列arr，返回所有get操作返回值累计和最大是多少？来自美团。

答案2022-05-26：

线段树。

代码用rust编写。代码如下：

fn main() {
    let mut arr: Vec<i32> = vec![1, 2, 3, 4, 5];
    let mut ops: Vec<Vec<i32>> = vec![vec![1, 3], vec![2, 4], vec![1, 5]];
    println!("ans = {}", max_gets(&mut arr, &mut ops));
}

fn max_gets(arr: &mut Vec<i32>, ops: &mut Vec<Vec<i32>>) -> i32 {
    let n = arr.len() as i32;
    let mut get_tree = SegmentTree::new(n);
    for op in ops.iter_mut() {
        if op.len() == 2 {
            get_tree.add(op[0], op[1], 1);
        }
    }
    let mut get_cnts: Vec<Vec<i32>> = vec![];
    for i in 0..n {
        get_cnts.push(vec![]);
        for _j in 0..2 {
            get_cnts[i as usize].push(0);
        }
    }
    let mut i: i32 = 1;
    let mut j: i32 = 0;
    while i <= n {
        get_cnts[j as usize][0] = j;
        get_cnts[j as usize][1] = get_tree.get(i, i);
        i += 1;
        j += 1;
    }
    get_cnts.sort_by(|a, b| a[1].cmp(&b[1]));
    arr.sort();
    let mut re_arrange: Vec<i32> = vec![];
    for _i in 0..n {
        re_arrange.push(0);
    }
    for i in 0..n {
        re_arrange[get_cnts[i as usize][0] as usize] = arr[i as usize];
    }
    let mut st = SegmentTree::new2(&mut re_arrange);
    let mut ans = 0;
    for op in ops.iter_mut() {
        if op.len() == 3 {
            st.add(op[0], op[1], op[2]);
        } else {
            ans += st.get(op[0], op[1]);
        }
    }
    return ans;
}
pub struct SegmentTree {
    pub n: i32,
    pub arr: Vec<i32>,
    pub sum: Vec<i32>,
    pub lazy: Vec<i32>,
}

impl SegmentTree {
    pub fn new(size: i32) -> Self {
        let mut n = size + 1;
        let mut sum: Vec<i32> = vec![];
        let mut lazy: Vec<i32> = vec![];
        let arr: Vec<i32> = vec![];
        for _i in 0..n << 2 {
            sum.push(0);
            lazy.push(0);
        }
        n -= 1;
        Self { n, arr, sum, lazy }
    }

    pub fn new2(origin: &mut Vec<i32>) -> Self {
        let mut n = origin.len() as i32 + 1;
        let mut arr: Vec<i32> = vec![];
        arr.push(0);
        for i in 1..n {
            arr.push(origin[(i - 1) as usize]);
        }
        let mut lazy: Vec<i32> = vec![];
        let mut sum: Vec<i32> = vec![];
        for _i in 0..n << 2 {
            sum.push(0);
            lazy.push(0);
        }
        n -= 1;
        let mut a = Self { n, arr, sum, lazy };
        a.build(1, n, 1);
        return a;
    }

    fn build(&mut self, l: i32, r: i32, rt: i32) {
        if l == r {
            self.sum[rt as usize] = self.arr[l as usize];
            return;
        }
        let mid = (l + r) >> 1;
        self.build(l, mid, rt << 1);
        self.build(mid + 1, r, rt << 1 | 1);
        self.push_up(rt);
    }

    fn push_up(&mut self, rt: i32) {
        self.sum[rt as usize] = self.sum[(rt << 1) as usize] + self.sum[(rt << 1 | 1) as usize];
    }

    fn push_down(&mut self, rt: i32, ln: i32, rn: i32) {
        if self.lazy[rt as usize] != 0 {
            self.lazy[(rt << 1) as usize] += self.lazy[rt as usize];
            self.sum[(rt << 1) as usize] += self.lazy[rt as usize] * ln;
            self.lazy[(rt << 1 | 1) as usize] += self.lazy[rt as usize];
            self.sum[(rt << 1 | 1) as usize] += self.lazy[rt as usize] * rn;
            self.lazy[rt as usize] = 0;
        }
    }

    pub fn add(&mut self, ll: i32, rr: i32, cc: i32) {
        self.add0(ll, rr, cc, 1, self.n, 1);
    }

    fn add0(&mut self, ll: i32, rr: i32, cc: i32, l: i32, r: i32, rt: i32) {
        if ll <= l && r <= rr {
            self.sum[rt as usize] += cc * (r - l + 1);
            self.lazy[rt as usize] += cc;
            return;
        }
        let mid = (l + r) >> 1;
        self.push_down(rt, mid - l + 1, r - mid);
        if ll <= mid {
            self.add0(ll, rr, cc, l, mid, rt << 1);
        }
        if rr > mid {
            self.add0(ll, rr, cc, mid + 1, r, rt << 1 | 1);
        }
        self.push_up(rt);
    }

    pub fn get(&mut self, ll: i32, rr: i32) -> i32 {
        return self.query(ll, rr, 1, self.n, 1);
    }

    fn query(&mut self, ll: i32, rr: i32, l: i32, r: i32, rt: i32) -> i32 {
        if ll <= l && r <= rr {
            return self.sum[rt as usize];
        }
        let mid = (l + r) >> 1;
        self.push_down(rt, mid - l + 1, r - mid);
        let mut ans = 0;
        if ll <= mid {
            ans += self.query(ll, rr, l, mid, rt << 1);
        }
        if rr > mid {
            ans += self.query(ll, rr, mid + 1, r, rt << 1 | 1);
        }
        return ans;
    }
}

执行结果如下：

在这里插入图片描述

左神java代码

关于将元组转换为 int - python和将元组转换为列表的问题就给大家分享到这里，感谢你花时间阅读本站内容，更多关于(int)、int.Parse()、int.TryParse()、Convert.ToInt32()区别、/编写一个函数，要求从给定的向量A中删除元素值在x到y之间的所有元素(向量要求各个元素之间不能有间断)，函数原型为int del(int A ,int n , int x , int y),其...、2022-03-11：int n, int[][] roads, int x, int y， n表示城市数量，城市编号0~n-1， roads[i][j] == distance，表示城市i到城市j距、2022-05-26：void add(int L, int R, int C)代表在arr[L...R]上每个数加C， int get(int L, int R)代表查询arr[L...R]上的累加等相关知识的信息别忘了在本站进行查找喔。

本文标签：