数据处理利器python与scala基本数据结构对比分析1-大数据ML样本集案例实战

时间  2019-11-17
标签 数据处理 利器 python scala 基本 数据 结构 对比 分析 样本 案例 实战 栏目 大数据 繁體版
原文   原文链接

版权声明：本套技术专栏是做者（秦凯新）平时工做的总结和升华，经过从真实商业环境抽取案例进行总结和分享，并给出商业应用的调优建议和集群环境容量规划等内容，请持续关注本套博客。QQ邮箱地址：1120746959@qq.com，若有任何学术交流，可随时联系。java

1 python与scala基本数据结构

1.1 scala 数据结构

  • List 案例python

    val l = List(1, 1, 2, 2, 3, 5)
 
 List元素的追加
 val list2 = list1 :+ 99
 println(list2)
 val list3 = 100 +: list1
 
 List的建立与追加，符号“::”，注意观察去掉Nil和不去掉Nil的区别
 scala> val list4 = 1 :: 2 :: 3 :: list1
 list4: List[Int] = List(1, 2, 3, 1, 2)
 
 scala> val list5 = 1 :: 2 :: 3 :: list1 :: Nil
 list5: List[Any] = List(1, 2, 3, List(1, 2))
 
 //map操做
 scala> l.map(_ * 2)
 res0: List[Int] = List(2, 4, 6, 8, 10)
 
 //filter操做
 scala> l.filter(_ > 2)
 res3: List[Int] = List(3, 4, 5)
 
 //collect操做
 scala> l.collect {case i if i > 2 => i * 2}
 res1: List[Int] = List(6, 8, 10)
 
 //定义一个列表
 scala> val l = List(List(1, 2, 3), List(4, 5, 6), Seq(7, 8, 9))
 l: List[Seq[Int]] = List(List(1, 2, 3), List(4, 5, 6), List(7, 8, 9))
 
 //flatten操做
 scala> l.flatten
 res5: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9)
 
 //flatMap操做
 scala> l.flatMap(i => i.map(_ * 2))
 res6: List[Int] = List(2, 4, 6, 8, 10, 12, 14, 16, 18)
 
 case class Student(
   name: String,
   age: Int,
   sex: String
 )
 val jilen = Student(
   name = "Jilen",
   age = 30,
   sex = "m"
 )
 val shaw = Student(
   name = "Shaw",
   age = 18,
   sex = "m"
 )
 val yison = Student(
   name = "Yison",
   age = 40,
   sex = "f"
 )
 val l = List(jilen, shaw, yison)
 l: List[Student] = List(Student(Jilen,30,m), Student(Shaw,18,m), Student(Yison,40,f))
 
 val nameList = l.map(_.name)
 nameList: List[String] = List(Jilen, Shaw, Yison)
 
 val maleList = l.filter(_.sex == "m")
 maleList: List[Student] = List(Student(Jilen,30,m), Student(Shaw,18,m))
 
 l.zipWithIndex
 List[(Student, Int)] = List((Student(Jilen,30,m),0), (Student(Shaw,18,m),1),(Student(Yison,40,f),2))

 
 val group = l.groupBy(_.sex)
 group: scala.collection.immutable.Map[String,List[Student]] = Map(m -> List(Student(Jilen,30,m), Student(Shaw,18,m)), f -> List(Student(Yison,40,f)))
复制代码

  • Array结构es6

    定义
  val arr1 = new Array[Int](10)
  //赋值
  arr1(1) = 7
  或：
  //定义
  val arr1 = Array(1, 2)
  //定义
  val arr2 = ArrayBuffer[Int]()
  //追加值
  arr2.append(7)
  //从新赋值
  arr2(0) = 7
  
  定长数组与变长数组的转换
  arr1.toBuffer
  arr2.toArray
  
  多维数组
  //定义
  val arr3 = Array.ofDim[Double](3,4)
  //赋值
  arr3(1)(1) = 11.11
  
  Scala数组转Java数组
  import scala.collection.JavaConversions.bufferAsJavaList
  val javaArr = new ProcessBuilder(arr4)
  println(javaArr.command())
  
  import scala.collection.JavaConversions.asScalaBuffer
  import scala.collection.mutable.Buffer
  val scalaArr: Buffer[String] = javaArr.command()
  println(scalaArr)
  
  for(x <- arr1) {
       println(x)
  }
复制代码

  • 元组 Tuple数组

    元组的建立
  val tuple1 = (1, 2, 3, "heiheihei")
  println(tuple1)
  
  元组数据的访问，注意元组元素的访问有下划线，而且访问下标从1开始，而不是0
  val value1 = tuple1._4
  println(value1)
  
  元组的遍历
  for (elem <- tuple1.productIterator) {
       print(elem)
  }
  
  tuple1.productIterator.foreach(i => println(i))
  tuple1.productIterator.foreach(print(_))
复制代码

  • 映射 Map数据结构

    构造不可变映射
  val map1 = Map("Alice" -> 10, "Bob" -> 20, "Kotlin" -> 30)
  
  构造可变映射
  val map2 = scala.collection.mutable.Map("Alice" -> 10, "Bob" -> 20, "Kotlin" -> 30)
  
  对偶元组 
  val map4 = Map(("Alice", 10), ("Bob", 20), ("Kotlin", 30))
  
  取值
  若是映射中没有值，则会抛出异常，使用contains方法检查是否存在key。若是经过 映射.get(键) 这样的调用返回一个Option对象，要么是Some，要么是None。
  val value1 = map1("Alice")//建议使用get方法获得map中的元素
  println(value1)
  scala> map1.get("Alice")
  res1: Option[Int] = Some(10)
  
  更新值
  map2("Alice") = 99
  println(map2("Alice"))
  或：
  map2 += ("Bob" -> 99)
  map2 -= ("Alice", "Kotlin")
  println(map2)
  或：
  val map5 = map2 + ("AAA" -> 10, "BBB" -> 20)
  println(map5)
  
  遍历
  for ((k, v) <- map1) println(k + " is mapped to " + v)
  for (v <- map1.keys) println(v)
  for (v <- map1.values) println(v)
  for(v <- map1) prinln(v)
复制代码

  • Set集合app

    集是不重复元素的结合。集不保留顺序，默认是以哈希集实现。
  
  Set不可变集合的建立
  val set = Set(1, 2, 3)
  println(set)
  
  Set可变集合的建立，若是import了可变集合，那么后续使用默认也是可变集合
  import scala.collection.mutable.Set
  val mutableSet = Set(1, 2, 3)
  
  可变集合的元素添加
  mutableSet.add(4)
  mutableSet += 6
  
  注意该方法返回一个新的Set集合，而非在原有的基础上进行添加
  mutableSet.+(5)//该方法至关于 “:+” 这个方法
  
  可变集合的元素删除
  mutableSet -= 1
  mutableSet.remove(2)
  println(mutableSet)
  
  for(x <- mutableSet) {
       println(x)
  }
复制代码

  • 迭代器函数

    val iterator = List(1, 2, 3, 4, 5).iterator
  while (iterator.hasNext) {
    println(iterator.next())
  }
  或：
  for(enum <- iterator) {
    println(enum)
  }
复制代码

1.2 python 数据结构

  • List 案例ui

    list1=['两点水','twowter','liangdianshui',123]
      # 经过索引来访问列表
      print(list1[2])
      # 经过方括号的形式来截取列表中的数据
      print(list1[0:2])
      # 经过索引对列表的数据项进行修改或更新
      list1[2]=456
      print(list1)
      # 使用 append() 方法来添加列表项
      list1.append('hello');
      print(list1)
      list1=['两点水','twowter','liangdianshui',123]
      print(list1)
      # 使用 del 语句来删除列表的的元素
      del list1[3]
      print(list1)
      
      函数&方法	            描述
      cmp(list1, list2)	比较两个列表的元素
      len(list)	列表元素个数
      max(list)	返回列表元素最大值
      min(list)	返回列表元素最小值
      list(seq)	将元组转换为列表
      list.append(obj)	在列表末尾添加新的对象
      list.count(obj)	统计某个元素在列表中出现的次数
      list.extend(seq)	在列表末尾一次性追加另外一个序列中的多个值（用新列表扩展原来的列表）
      list.index(obj)	从列表中找出某个值第一个匹配项的索引位置
      list.insert(index, obj)	将对象插入列表
      list.pop(obj=list[-1])	移除列表中的一个元素（默认最后一个元素），而且返回该元素的值
      list.reverse()	反向列表中元素
      list.sort([func])	对原列表进行排序  
复制代码

  • Tuple元祖（两种建立，不可变）es5

    tuple1=('两点水','twowter','liangdianshui',123,456)
  tuple2='两点水','twowter','liangdianshui',123,456   
  元组中只包含一个元素时，须要在元素后面添加逗号
  tuple4=(123,)
  print(tuple1[1])
  print(tuple2[0])
复制代码

#-*-coding:utf-8-*-
    list1=[123,456]
    tuple1=('两点水','twowater','liangdianshui',list1)
    print(tuple1)
    list1[0]=789
    list1[1]=100
    print(tuple1)

    ('两点水', 'twowater', 'liangdianshui', [123, 456])
    ('两点水', 'twowater', 'liangdianshui', [789, 100])
    
    tuple1=('两点水','twowter','liangdianshui',[123,456])
    print(tuple1)
    del tuple1
复制代码

  • dict （字典，可变容器模型，且可存储任意类型对象）spa

    #-*-coding:utf-8-*-
  dict1={'liangdianshui':'111111' ,'twowater':'222222' ,'两点水':'333333'}
  print(dict1)
  # 新增一个键值对
  dict1['jack']='444444'
  print(dict1)
  # 修改键值对
  dict1['liangdianshui']='555555'
  print(dict1)
  
  {'liangdianshui': '111111', 'twowater': '222222', '两点水': '333333'}
  {'liangdianshui': '111111', 'twowater': '222222', '两点水': '333333', 'jack': '444444'}
  {'liangdianshui': '555555', 'twowater': '222222', '两点水': '333333', 'jack': '444444'}
  
  #-*-coding:utf-8-*-
  dict1={'liangdianshui':'111111' ,'twowater':'222222' ,'两点水':'333333'}
  print(dict1)
  # 经过 key 值，删除对应的元素
  del dict1['twowater']
  print(dict1)
  # 删除字典中的全部元素
  dict1.clear()
  print(dict1)
  # 删除字典
  del dict1
复制代码

  • set 无序不重复元素集

    set1=set([123,456,789,123,123])
  print(set1)
复制代码

3 总结

秦凯新 于深圳

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程