首页 文章 精选 留言 我的

精选列表

搜索[基础搭建]，共10000篇文章
优秀的个人博客,低调大师

linux基础-1

1、常见Linux的发行版有哪些？并描述不同发行版之间的联系与区别SUSEUbuntumintRHELCentOS中标麒麟FedoraArchLinuxGentooAndroid所有版本都有相同的linux内核由不同的组织发行，因为组织不同所以系统的特性也不同2、打印显示当前时间，格式是：20181209211008 date +%G%m%d%N3、实现晚上20:30自动关机，并提示用户shutdown -s 20:304、总结历史命令管理以及用法history命令，可以显示曾经使用过的命令，系统会把历史命令写到用户的家目录下的一个文件里，用户登录后，系统会读取这个文件里的所有历史命令到内存。而history这个命令可以吧历史命令显示出来，显示出来的历史命令前有序号，可以通过!n 的方式执行历史命令5、总结Linux帮助用法linux上有帮助相关的命令有：whatiscommand --helpman and info/usr/share/doc/Red Hat documentation其他途径：网上搜索，与求助
2019-08-11
优秀的个人博客,低调大师

kubernetes基础使用

官方文档：https://v1-13.docs.kubernetes.io/zh/docs/tutorials/kubernetes-basics/pods生命周期:https://v1-13.docs.kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/配置: https://v1-13.docs.kubernetes.io/docs/concepts/configuration/labels: https://v1-13.docs.kubernetes.io/docs/concepts/overview/working-with-objects/labels/Deployments: https://v1-13.docs.kubernetes.io/docs/concepts/workloads/controllers/deployment/Services: https://v1-13.docs.kubernetes.io/docs/concepts/services-networking/service/Scaling: https://v1-13.docs.kubernetes.io/docs/tutorials/kubernetes-basics/scale/scale-intro/autoscale: https://v1-13.docs.kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale/ #查看k8s版本 kubectl version #查看所有的节点 kubectl get nodes #获取namespace kubectl get namespace #查看namespace为online的pod kubectl get pods --namespace=online #部署应用 kubectl run kubernetes-bootcamp --image=jocatalin/kubernetes-bootcamp:v1 --port=8080 #查看部署应用列表 kubectl get deployments --namespace= #查看所有pod kubectl get pods --namespace= #获取执行中的pod并设置成环境变量POD_NAME export POD_NAME=$(kubectl get pods -o go-template --template '{{range .items}}{{.metadata.name}}{{"\n"}}{{end}}') echo Name of the Pod: $POD_NAME #访问pod curl http://localhost:8001/api/v1/namespaces/default/pods/$POD_NAME/proxy/ kubectl 故障排查 kubectl get pods --namespace= #查看resources列表 kubectl describe pods --namespace= #查看具体的resources情况 kubectl logs $POD_NAME --namespace= #查看pod里的容器日志 kubectl exec --namespace= #在pod里的容器里执行命令 kubectl exec $POD_NAME env --namespace= #查看pod环境变量 kubectl exec -ti $POD_NAME bash --namespace= #进入pod终端 Service & labelsService type 类型 说明 ClusterIP 默认选项，只能集群内部访问 NodePort 使用NAT暴露每个节点的相同端口并使用<NodeIP>:<NodePort> 方式让集群外部访问ClusterIP的超集 LoadBalancer 创建负载均衡器分配一个固定的IPNodePort的超集 ExternalName 使用域名解析的CNAME来指定名字或者手动自定名字不使用proxy 需要v1.7及以上版本的kube-dns 更多的内容参考:https://v1-13.docs.kubernetes.io/docs/tutorials/services/source-ip/ https://v1-13.docs.kubernetes.io/docs/concepts/services-networking/connect-applications-service/ labelsservice通过labels把一组pods管理起来。比如通过labels指定开发、测试、生产环境比如打版本tag使用标签分类 #获取service kubectl get services --namespace= #指定service type kubectl expose deployment/kubernetes-bootcamp --type="NodePort" --port 8080 #查看指定services信息 kubectl describe services/kubernetes-bootcamp --namespace= #设置NODE_PORT端口为环境变量 export NODE_PORT=$(kubectl get services/kubernetes-bootcamp -o go-template='{{(index .spec.ports 0).nodePort}}') echo NODE_PORT=$NODE_PORT #查看部署情况 kubectl describe deployment --namespace= #-l根据label查询pods kubectl get pods -l run=kubernetes-bootcamp --namespace= #-l根据label查询services kubectl get services -l run=kubernetes-bootcamp --namespace= export POD_NAME=$(kubectl get pods -o go-template --template '{{range .items}}{{.metadata.name}}{{"\n"}}{{end}}') echo Name of the Pod: $POD_NAME #设置label,label是key/value对 kubectl label pod $POD_NAME app=v1 #根据label查询pods kubectl get pods -l app=v1 --namespace= #删除service kubectl delete service -l run=kubernetes-bootcamp --namespace= #pod里执行命令 kubectl exec -ti $POD_NAME curl localhost:8080 --namespace= 扩缩容 kubectl get deployments #扩容成4个 kubectl scale deployments/kubernetes-bootcamp --replicas=4 #查看pod是否变成4个 kubectl get pods -o wide #查看deployments详情 kubectl describe deployments/kubernetes-bootcamp #设置环境变量 export NODE_PORT=$(kubectl get services/kubernetes-bootcamp -o go-template='{{(index .spec.ports 0).nodePort}}') echo NODE_PORT=$NODE_PORT #缩容 kubectl scale deployments/kubernetes-bootcamp --replicas=2 滚动升级 #查看deployments kubectl get deployments kubectl get pods kubectl describe pods #滚动升级 kubectl set image deployments/kubernetes-bootcamp kubernetes-bootcamp=jocatalin/kubernetes-bootcamp:v2 #查看升级是否成功 kubectl describe services/kubernetes-bootcamp #查看升级状态 kubectl rollout status deployments/kubernetes-bootcamp #升级一个不存在的版本，让升级失败。 kubectl set image deployments/kubernetes-bootcamp kubernetes-bootcamp=gcr.io/google-samples/kubernetes-bootcamp:v10 #查看pods是否失败 kubectl get pods #查看失败日志 kubectl logs $POD_NAME #回退版本，然后用上面的命令查看是否回退成功 kubectl rollout undo deployments/kubernetes-bootcamp 根据上面的内容部署官网的例子:https://kubernetes.io/docs/tutorials/stateless-application/guestbook/image 从docker hub 上找，先pull下来 #在有问题的node上执行以下命令 查看问题 journalctl -f -u kubelet
2019-04-02
优秀的个人博客,低调大师

Javascript基础之-this

this应该算是前期比较容易混淆的一个关键字了，在这里，我就打算按照我的理解来说一下 首先呢，this的值是跟运行时被调用的位置相关的，而不是词法作用域。 也就是说，他的绑定的值很可能是动态的，不同的调用位置，很可能值就不一样，比如说： function foo() { console.log(this.a); } var a = 2; var obj = { a: 3, foo, } foo(); //2 obj.foo(); //3 var c = obj.foo; c(); //2 然后你会惊讶的发现，foo()通过不同的形式调用，他最终的值是不一样的，咱们这一节主要就来讲一讲他们里面的这些绑定的规则 默认绑定 独立的函数调用，它的作用域是作用在全局的，这种绑定规则最常见并且是优先级最低的一种绑定规则。来一个例子 function foo() { console.log(this.a); //2 console.log(this === window); //true } var a = 2; foo(); 在浏览器中执行，会发现，如果foo()作为一个函数单独调用，那么this指向的就是全局对象windows。 但是呢，也有一种例外，如果函数使用的严格模式的话，那么全局对象讲无法使用默认绑定，this将会绑定到undefined，还是刚才的例子： function foo() { "use strict" console.log(this.a); console.log(this === window); } var a = 2; foo(); //Uncaught TypeError: Cannot read property 'a' of undefined 可以看到，foo直接抛出一个error，说this是undefined，取不到a，如果用到严格模式的时候，可以稍微注意下这个区别 咱们刚刚的例子，说的是函数内用严格模式的话，讲无法使用默认绑定，那么如果是在函数调用位置用严格模式，会受影响吗 function foo() { console.log(this.a); //2 console.log(this === window); //true } var a = 2; (function () { "use strict" foo(); })(); 很明显，可以看出，是不受影响的，还有一个问题，如果把var定义变成let会怎么样呢 function foo() { console.log(this.a); //undefined console.log(this === window); //true } let a = 2; (function () { "use strict" foo(); })(); 也就是说，let定义并不会加到全局变量中，这个和var的区别需要稍微留意一下 隐式绑定 这一条规则考虑的是是否有上下文对象，举个例子 function foo() { console.log(this.a); //2 console.log(this === obj); // true } var obj = { a: 2, foo, } obj.foo(); 在这种情况下，foo会使用obj的上下文对象来引用函数，此时的this指向的就是obj。 那么如果是嵌套对象这种的，会怎么处理呢？ function foo() { console.log(this.a); // 1 console.log(this === obj) // true console.log(this === obj1) // fale } var obj = { a: 1, foo, }; var obj1 = { a: 2, obj, } obj1.obj.foo(); 可以看到，实际上此时foo中的this指向了离他最近的对象obj，也就是说，对象属性引用链的最后一层会影响它的调用位置 还有一种情况。 function foo() { console.log(this.a); } var obj = { a: 3, foo, } var a = 2; var f = obj.foo; f(); // 2 这种情况下，虽然f是obj.foo的引用，但是最后依然用的是默认绑定，而不是隐式绑定，所以说呢，咱们可以这么理解，虽然他是对象中函数的引用，但是在执行的时候，调用的方式确是函数调用的方式，不是对象.属性()的方式，这块在使用的时候需要注意一下 显式绑定 很简单，显式绑定就是手动直接改变其this指向的一种方式，这个主要是用几种api来实现的 function foo() { console.log(this.a); } var obj = { a: 2, }; foo.call(obj); foo.apply(obj); var f = foo.bind(obj); f(); 这个就是显式绑定的常见的三种形式 这三种形式的话，call和apply差不多，就不展开了，详情看文档就行，咱们仔细看一下bind函数，来在看一个例子 function foo(num1, num2) { console.log(num1 + num2); //5 console.log(this === obj); // true } var obj = { a: 1, }; var f = foo.bind(obj, 2); f(3); 这个可以看出，bind的用法和call以及apply还是有一些差别的。 注意，如果显式绑定传入的是null或者是undefined的话，将会使用默认绑定规则，举个例子 function foo() { console.log( this.a ); } var a = 2; foo.call( null ); // 2 new绑定 这个主要是new 函数()的绑定形式的，这个的this指向的是函数构造出的那个对象，new的时候，它的执行过程可以大概执行以下几步 创建一个全新的对象 这个新对象会被执行prototype连接 新对象绑定到函数调用的this 如果函数没有返回其他对象，那么new表达式中的函数调用会自动返回这个新对象 注意最后一句话，如果函数没有返回对象，那么就会返回函数调用的新对象，如果返回了一个对象呢，那么结果就是直接返回这个对象 var abc = { a: 10 } function foo() { return abc; } foo.prototype = { b: 20 }; var a = new foo(); console.log(a === abc); // true console.log(a.b); // undefined function bar() { this.a = 10; } bar.prototype = { b: 20 }; var b = new bar(); console.log(b.a); // 10 console.log(b.b); // 20 以上四种常见的this绑定方式已经介绍的差不多了，那么问题来了，谁的优先级更高呢 很明显，默认绑定的优先级最低，就不展开说了 显式绑定与隐式绑定哪个优先级高呢，举个例子 function foo() { console.log( this. a ); } var obj1 = { a: 2, foo: foo }; var obj2 = { a: 3, foo: foo }; obj1.foo(); // 2 obj2.foo(); // 3 obj1.foo.call( obj2 ); // 3 obj2.foo.call( obj1 ); // 2 很明显，显式绑定优先级要高于隐式绑定 那么new绑定和显式绑定谁更高呢，来再看个例子 function foo(something) { this.a = something; } var obj1 = {}; var bar = foo.bind( obj1 ); bar( 2 ); console.log( obj1.a ); // 2 var baz = new bar(3); console.log( obj1.a ); // 2 console.log( baz.a ); // 3 很明显，new的优先级会更高 所以，这样的话，优先级排序就出来了，分别为 new绑定 > 显式绑定 ＞ 隐式绑定 ＞ 默认绑定 以上就是大家常用到的几种，不过es6出现了一种箭头函数，箭头函数理论上不能应用上面四种的任意一种，它的this是根据代码的词法作用域来走的，比如说 function foo() { return (a) => { console.log( this.a ); }; } var obj1 = { a: 2 }; var obj2 = { a: 3 }; var bar = foo.call( obj1 ); bar.call( obj2 ); // 2 结果已经很明显了， 好了，以上内容就讲完了，通过我的一些讲解，是不是有一点理解了呢，如果有任何的不同意见，欢迎讨论哦 参考书籍《你不知道的Javascript》上卷 转载自：http://www.lht.ren/article/4/
2019-01-16
优秀的个人博客,低调大师

Kotlin 基础语法

Kotlin 文件以 .kt 为后缀。 包声明 包的声明应处于源文件顶部： package my.demo import java.util.* // …… kotlin源文件不需要相匹配的目录和包，源文件可以放在任何文件目录。如果没有指定包，默认为default包。 默认导入 有多个包会默认导入到每个 Kotlin 文件中： kotlin.* kotlin.annotation.* kotlin.collections.* kotlin.comparisons.* kotlin.io.* kotlin.ranges.* kotlin.sequences.* kotlin.text.* 函数定义 函数定义使用关键字 fun，参数格式为： 参数 : 类型，下面给出几个例子 //带有两个 Int 参数、返回 Int 的函数 fun sum(a: Int, b: Int): Int { // Int 参数，返回值 Int return a + b } 表达式作为函数体，返回类型自动推断： fun sum(a: Int, b: Int) = a + b public fun sum(a: Int, b: Int): Int = a + b // public 方法则必须明确写出返回类型 无返回值的函数(类似Java中的void)： fun printSum(a: Int, b: Int): Unit { println("sum of $a and $b is ${a + b}") } // 如果是返回 Unit类型，则可以省略(对于public方法也是这样)： public fun printSum(a: Int, b: Int) { print(a + b) } 可变长参数函数 函数的变长参数可以用vararg关键字进行标识： fun vars(vararg v:Int){ for(vt in v){ print(vt) } } // 测试 fun main(args: Array<String>) { vars(1,2,3,4,5) // 输出12345 } lambda(匿名函数) lambda表达式使用实例： // 测试 fun main(args: Array<String>) { val sumLambda: (Int, Int) -> Int = {x,y -> x+y} println(sumLambda(1,2)) // 输出 3 } 定义常量与变量 不可变变量定义：val 关键字，只能赋值一次的变量(类似Java中final修饰的变量) val <标识符> : <类型> = <初始化值> 可变变量定义：var 关键字 var <标识符> : <类型> = <初始化值> 常量与变量都可以没有初始化值,但是在引用前必须初始化 编译器支持自动类型判断,即声明时可以不指定类型,由编译器判断。 val a: Int = 1 // 立即赋值 val b = 1 // 系统自动推断变量类型为Int val c: Int // 如果不在声明时初始化,则必须提供变量类型 c = 1 // 明确赋值 var x = 5 // 系统自动推断变量类型为Int x += 1 // 变量可修改 注释 Kotlin 支持单行和多行注释，实例如下： // 这是一个单行注释 /* 这是一个多行的 块注释。 */ 与 Java 不同, Kotlin 中的块注释允许嵌套。 字符串模板 $ 表示一个变量名或者变量值 $varName 表示变量值 ${varName.fun()} 表示变量的方法返回值: var a = 1 // 模板中的简单名称： val s1 = "a is $a" a = 2 // 模板中的任意表达式： val s2 = "${s1.replace("is", "was")}, but now is $a" NULL检查机制 Kotlin的空安全设计对于声明可为空的参数，在使用时要进行空判断处理，有两种处理方式，字段后加!!像Java一样抛出空异常，另一种字段后加?可不做处理返回值为 null或配合?:做空判断处理 //类型后面加?表示可为空 var age: String? = "23" //抛出空指针异常 val ages = age!!.toInt() //不做处理返回 null val ages1 = age?.toInt() //age为空返回-1 val ages2 = age?.toInt() ?: -1 当一个引用可能为 null 值时, 必须在声明处的类型后添加?来标识该引用可为空 当 str 中的字符串内容不是一个整数时, 返回 null: fun parseInt(str: String): Int? { // ... } 以下实例演示如何使用一个返回值可为 null 的函数: fun printProduct(arg1: String, arg2: String) { val x = parseInt(arg1) val y = parseInt(arg2) // 直接使用 `x * y` 会导致错误, 因为它们可能为 null. if (x != null && y != null) { // 在进行过 null 值检查之后, x 和 y 的类型会被自动转换为非 null 变量 print(x * y) } } 或者 // …… if (x == null) { println("Wrong number format in arg1: '$arg1'") return } if (y == null) { println("Wrong number format in arg2: '$arg2'") return } ​ // 在空检测后，x 与 y 会自动转换为非空值 println(x * y) 类型检测及自动类型转换 我们可以使用 is 运算符检测一个表达式是否是某类型的一个实例(类似于Java中的instanceof关键字)。如果一个不可变的局部变量或属性已经判断出为某类型，那么检测后的分支中可以直接当作该类型使用，无需显式转换： fun getStringLength(obj: Any): Int? { if (obj is String) { // 做过类型判断以后，obj会被系统自动转换为String类型 return obj.length } // 在离开类型检测分支后，`obj` 仍然是 `Any` 类型 return null } 在这里还有一种方法，与Java中instanceof不同，使用!is fun getStringLength(obj: Any): Int? { fun getStringLength(obj: Any): Int? { if (obj !is String) return null // `obj` 在这一分支自动转换为 `String` return obj.length } 甚至还可以 fun getStringLength(obj: Any): Int? { // 在 `&&` 运算符的右侧, `obj` 的类型会被自动转换为 `String` if (obj is String && obj.length > 0) return obj.length return null } 区间 区间表达式由具有操作符形式..的 rangeTo 函数辅以 in 和 !in 形成。 区间是为任何可比较类型定义的，但对于整型原生类型，它有一个优化的实现。以下是使用区间的一些示例: for (i in 1..4) print(i) // 输出“1234” for (i in 4..1) print(i) // 什么都不输出 if (i in 1..10) { // 等同于 1 <= i && i <= 10 println(i) } // 使用 step 指定步长 for (i in 1..4 step 2) print(i) // 输出“13” for (i in 4 downTo 1 step 2) print(i) // 输出“42” // 使用 until 函数排除结束元素 for (i in 1 until 10) { // i in [1, 10) 排除了 10 println(i) } 实例测试 fun main(args: Array<String>) { print("循环输出：") for (i in 1..4) print(i) // 输出“1234” println("\n----------------") print("设置步长：") for (i in 1..4 step 2) print(i) // 输出“13” println("\n----------------") print("使用 downTo：") for (i in 4 downTo 1 step 2) print(i) // 输出“42” println("\n----------------") print("使用 until：") // 使用 until 函数排除结束元素 for (i in 1 until 4) { // i in [1, 4) 排除了 4 print(i) } println("\n----------------") } 输出结果： 循环输出：1234 ---------------- 设置步长：13 ---------------- 使用 downTo：42 ---------------- 使用 until：123 ---------------- 参考： http://www.runoob.com/kotlin/kotlin-basic-syntax.html https://www.kotlincn.net/docs/reference/basic-syntax.html
2018-12-09
优秀的个人博客,低调大师

Java基础1.3

什么是批处理：批处理就是多个dos命令组成的，双击可执行里面的命令。（微软系统） 批处理：桌面文件以双击就能打开，而java一双击是打不开的因为java是一个class文件他需要虚拟机得运行才能打开。 Java不擅长做桌面程序你要是非要做你就得写一个简单的批处理操作。 run.bat：在批处理文件中运行你要运行的文件（java，javaw）加文件名。 bat(批处理的后缀)批处理就是dos的命令。javaw窗口文件运行，使用java不能关闭dos的窗口就是关闭程序的运行，这里是指窗口件。start（开启命令）犹如在dos中运行程序， 要想将你写的程序传播出去，就需要将源码（文件名.java）字节码（文件名.class）批处理（文件名.bat） 还要带上jdk 并且在批处理 bat文件中配置临时环境变量 ， JAVA_HOME配置的是子目录前的路径 在配置path的时候不要在配置目录了只需要引入JAVA_HOME即可 set path=./jdk-10.0.2./bin（）当前目录显得bin目录 .（代表当前目录下执行） set JAVA_HOME =./jdk-10.0.2（当前路径下的jdk） .（代表当前目录先执行） set CLASSPATH= . ;(当前目录) 这里有语法规定当前目录是（.;） 批处理就是字一个记事本中写执行代码让系统顺着去执行。 Java程序永远离不开jdk 就算你生成了exe也需要jdk才能运行。 如果想直接运行也可以就需要通过一个工具（exej4）这个工具可以直接将java打包成exe可执行程序。(这个你看到的只是假象 他只是做了一个批处理) 所以还不如我们自己写一个批处理
2018-08-09
优秀的个人博客,低调大师

Java基础1.1

虚拟机：vm，java虚拟机jvm。 C语言：写源码；用文本文件写的（写出来就是一个文本文件）。 源码————编译————可执行程序。 运行平台（系统+硬件）。 C；优点：与系统接触近，可以操作系统和系统API 缺点：程序不可跨平台，内存管理十分的麻烦。 内存（运行内存）又称闪存 ———速度十分的快——（一旦掉电数据全部消失）服务器（数据服务中心）服务器运行时间很长。内存运行完要回收 Java优化：如何跨平台（在所有操作系统上运行），如何管理内存（让所有的程序员不在头疼如何管理内存） 怎样跨平台； 三大系统的内核不一样：如何让程序可以跨平台运行那【源码】————【字节码】—————【翻译官】（虚拟机），字节码交给翻译官 怎样优化内存：C语言————编译——-exe————运行 虚拟机就像一个鱼缸： 你要操作内存的话交个容器，虚拟机就像是一个管家；你不用管内存，交给管家就行了，你想要内存问这个管家要就行了。 为什么要形成字节码： 把源码转换为字节码，能让虚拟机很快的认识，运行速度就快。（加快运行速度在运行的时候不用再次解析代码了）优化速度。
2018-08-09
优秀的个人博客,低调大师

Java 基础语法

基本语法 2.1关键字 关键字是电脑语言里事先定义的，有特别意义的标识符，有时又叫保留字，还有特别意义的变量。Java的关键字对Java的编译器有特殊的意义，他们用来表示一种数据类型，或者表示程序的结构等，关键字不能用作变量名、方法名、类名、包名和参数。 Java语言规定关键字不能作为标识符。目前共有50个Java关键字，其中，"const"和"goto"这两个关键字在Java语言中并没有具体含义。Java语言把它们列为关键字，只是因为"const"和"goto"是其他某些计算机语言的关键字。2.2 标识符2.2.1 含义Java语言中，对于变量，常量，函数，语句块也有名字，我们统统称之为Java标识符.标识符是用来给类、对象、方法、变量、接口和自定义数据类型命名的。2.2.2 组成Java标识符由数字，字母和下划线（_），美元符号（$）或人民币符号（￥）组成。在Java中是区分大小写的，而且还要求首位不能是数字。最重要的是，Java关键字不能当作Java标识符。2.2.3 命名规则1.类和接口名。每个字的首字母大写，含有大小写。例如MyClass，HelloWorld等。2.方法名。首字符小写，其余的首字母大写，含大小写。尽量少用下划线。例如，myName等。这种命名方法叫做驼峰式命名。3.常量名。基本数据类型的常量名使用全部大写字母，字与字之间用下划线分隔。对象常量可大小混写。例如，SIZE_NAME。 4.变量名。可大小写混写，首字符小写，字间分隔符用字的首字母大写。不用下划线，少用美元符号。给变量命名是尽量做到见名知义。 2.3 运算符2.3.1分类1.算数运算符（1）单目：+（取正）-（取负） ++（自增1） - -（自减1）（◆注：++和—既可以是前置运算符，也可以是后置运算符。前置时，变量的值先增1或先减1，然后用变量参加表达式的计算；后置时，变量的值先参加表达式的计算，然后变量再增1或减1。）（2）双目：+（加） -（减） *（乘） /（除） %（取余）2.赋值运算符（一）简单赋值运算符“=”用来将一个数据赋给一个变量（二）复合赋值运算符（1）= （2） += （3） -= （4） *= （5） /= （6） %= （7） &= （8） ^= （9）|= （10） <<= （11） >>=3.关系运算符等于符号==，不等于符号!= ，大于符号 >， 小于符号<，大于等于符号: >= ，小于等于符号: <= 。4.短路运算符短路运算符就是我们常用的“&&”、“||”，一般称为“条件操作”。5.条件运算符三目：a>b?true:false 说明：当a大于b的时候，为true（也就是冒号之前的值），否则为false；这整个运算符包括一个关系运算符（可以是“>”"<""!="等等），一个“？”，一个“：”，冒号前后需要有两个表达式或者是值或者是对象。6.位运算符（1）逻辑运算符常见的共有4种逻辑位运算符：（~）按位取反（&）按位与（|）按位或（^）按位异或(2)移位运算符（a）左移动运算符：会将操作的数向左边移动，移动的位的个数由指定，左移（b）右移动运算符：反过来，把操作数向右移动，移动的位个数同样由右操作数指定。（c）无正负号的右移运算符(>>>)：7.布尔运算符布尔运算符布尔(boolean)变量或表达式的组合运算可以产生新的boolean值，fales和true(记得是小写)。单目运算符“!”是布尔非。双目运算符&，|和^是逻辑AND，OR和XOR运算符，它们强制两个操作数求布尔值。为避免右侧操作数冗余求值，用户可以使用短路求值运算符&&和||。8.其他运算符（1）instanceof（运行时的类型识别）（2）. 点运算符，用来访问对象实例和访问类的成员方法和成员方法。（3）（） “（）”运算符，当声明或调用一个方法时，可以在（）之间列出方法的参数，也可以利用“（）”来指定一个空的参数。（4）new运算符 可以使用new运算符来出创建一个新对象或者一个新的数组（5）[]运算符 可以使用方括号来声明数组、创建数组以及访问数组中的元素。2.3.2 优先级按优先级从高到低排列如下：[ ] ( ) ++ -- ! ～ instanceof * / % + - << >> >>> <> < = > \ == != &^& & || ? := op= 。
2018-08-05
优秀的个人博客,低调大师

JavaScript 基础--- (对象)

1、js的String对象 ** 创建String对象 *** var str = "abc"; ** 方法和属性（文档） *** 属性 length：字符串的长度 *** 方法 （1）与html相关的方法 - bold()：加粗 - fontcolor(): 设置字符串的颜色 - fontsize(): 设置字体的大小 - link(): 将字符串显示成超链接 **** str4.link("hello.html") - sub() sup(): 下标和上标 （2）与java相似的方法 - concat(): 连接字符串 ** //concat方法 <!doctype html> <html lang="en"> <head> <meta charset="UTF-8" /> <title>对象</title> <script> var str1 = "abc"; var str2 = "dfg"; document.write(str1.concat(str2)); //连接字符串 </script> </head> <body> </body> </html> 输出： - charAt():返回指定指定位置的字符串 <!doctype html> <html lang="en"> <head> <meta charset="UTF-8" /> <title>对象</title> <script> var str3 = "abcdefg"; document.write(str3.charAt(20)); //字符位置不存在，返回空字符串 </script> </head> <body> </body> </html> 输出：空- indexOf()： 返回字符串位置 <!doctype html> <html lang="en"> <head> <meta charset="UTF-8" /> <title>对象</title> <script> var str4 = "poiuyt"; document.write(str4.indexOf("w")); //字符不存在，返回-1 </script> </head> <body> </body> </html> 输出：- split()：切分字符串，成数组 <!doctype html> <html lang="en"> <head> <meta charset="UTF-8" /> <title>对象</title> <script> var str5 = "a-b-c-d"; var arr1 = str5.split("-"); document.write("length: "+arr1.length); </script> </head> <body> </body> </html> 输出： - replace() ： 替换字符串 * 传递两个参数： -- 第一个参数是原始字符 -- 要替换成的字符 <!doctype html> <html lang="en"> <head> <meta charset="UTF-8" /> <title>对象</title> <script> var str6 = "abcd"; document.write(str6); document.write("<br/>"); document.write(str6.replace("a","Q")); </script> </head> <body> </body> </html> 输出：- substr()和substring() <!doctype html> <html lang="en"> <head> <meta charset="UTF-8" /> <title>对象</title> <script> var str7 = "abcdefghuiop"; document.write(str7.substr(5,5)); //从第五位开始，向后截取五个字符 document.write("<br/>"); document.write(str7.substring(3,5));//从第三位开始到第五位结束[3,5)[左闭右开] </script> </head> <body> </body> </html> 输出： 2、js的Array对象 ** 创建数组（三种） - var arr1 = [1,2,3]; - var arr2 = new Array(3); //长度是3 - var arr3 = new Array(1,2,3); //数组中的元素是1 2 3 - var arr = []; //创建一个空数组 ** 属性：length：查看数组的长度 ** 方法 - concat方法： 数组的连接 * var arr11 = [1,2,3]; var arr12 = [4,5,6]; document.write(arr11.concat(arr12)); - join()：根据指定的字符分割数组 <!doctype html> <html lang="en"> <head> <meta charset="UTF-8" /> <title>对象</title> <script> var arr13 = new Array(3); arr13[0] = "a"; arr13[1] = "b"; arr13[2] = "c"; document.write(arr13); document.write("<br/>"); document.write(arr13.join("-")); </script> </head> <body> </body> </html> 输出： - push():向数组末尾添加元素，返回数组的新的长度 ** 如果添加的是一个数组，这个时候把数组当做一个整体字符串添加进去 * //push方法 <!doctype html> <html lang="en"> <head> <meta charset="UTF-8" /> <title>对象</title> <script> var arr14 = new Array(3); arr14[0] = "tom"; arr14[1] = "lucy"; arr14[2] = "jack"; document.write("old array: "+arr14); document.write("<br/>"); document.write("old length:"+arr14.length); document.write("<br/>"); document.write("new length: "+arr14.push("zhangsan")); document.write("<br/>"); document.write("new array: "+arr14); </script> </head> <body> </body> </html> 输出： <!doctype html> <html lang="en"> <head> <meta charset="UTF-8" /> <title>对象</title> <script> var arr15 = ["aaa","bbb","ccc"]; var arr16 = ["www","qqq"]; document.write("old array:"+arr15); document.write("<br/>"); document.write("old length:"+arr15.length); document.write("<br/>"); document.write("new length:"+arr15.push(arr16)); document.write("<br/>"); document.write("new array: "+arr15); for(var i=0;i<arr15.length;i++) { alert(arr15[i]); } </script> </head> <body> </body> </html> 输出： - pop()：表示 删除最后一个元素，返回删除的那个元素 <!doctype html> <html lang="en"> <head> <meta charset="UTF-8" /> <title>对象</title> <script> var arr17 = ["zhangsan","lisi","wangwu","zhaoliu"]; document.write("old array: "+arr17); document.write("<br/>"); document.write("return: "+arr17.pop()); document.write("<br/>"); document.write("new array: "+arr17); </script> </head> <body> </body> </html> 输出：- reverse():颠倒数组中的元素的顺序 <!doctype html> <html lang="en"> <head> <meta charset="UTF-8" /> <title>对象</title> <script> document.write("<hr/>"); var arr18 = ["zhangsan1","lisi1","zhaoliu1","niuqi1"]; document.write("old array: "+arr18); document.write("<br/>"); document.write("new array:"+arr18.reverse()); </script> </head> <body> </body> </html> 输出： 3、js的Date对象 ** 在java里面获取当前时间 Date date = new Date(); //格式化 //toLocaleString() ** js里面获取当前时间 var date = new Date(); //获取当前时间 var date = new Date(); document.write(date); //转换成习惯的格式 document.write("<hr/>"); document.write(date.toLocaleString()); ** 获取当前的年方法 getFullYear()：得到当前的年 **** document.write("year: "+date.getFullYear()); ** 获取当前的月方法 getMonth()：获取当前的月 *** 返回的是 0-11月，如果想要得到准确的值，加1 **** var date1 = date.getMonth()+1; document.write("month: "+date1); ** 获取当前的星期 getDay()：星期,返回的是 (0 ~ 6) ** 外国朋友，把星期日作为一周的第一天，星期日返回的是 0 而星期一到星期六 返回的是 1-6 ** document.write("week: "+date.getDay()); ** 获取当前的日 getDate()：得到当前的天 1-31 ** document.write("day: "+date.getDate()); <!DOCTYPE html> <html> <head> <meta charset="UTF-8"> <title>对象</title> <script type="text/javascript"> var date = new Date(); var days = ['周日','周一','周二','周三','周四','周五','周六']; document.write(days[date.getDay()]) </script> </head> <body> </body> </html> 输出： ** 获取当前的小时 getHours()：获取小时 ** document.write("hour: "+date.getHours()); ** 获取当前的分钟 getMinutes()：分钟 ** document.write("minute: "+date.getMinutes()); ** 获取当前的秒 getSeconds(): 秒 ** document.write("second: "+date.getSeconds()); ** 获取毫秒数 getTime() 返回的是1970 1 1 至今的毫秒数 ** 应用场景： *** 使用毫秒数处理缓存的效果（不有缓存） 案例：输出当前年、月、日、时、分、秒（动态变化） <!DOCTYPE html> <html> <head> <meta charset="UTF-8"> <title></title> <script type="text/javascript"> document var interval = setInterval("clock()",1000); function clock(){ var date = new Date(); var div1 = document.getElementById('div1'); div1.innerHTML = formatDate(date); } function pause(){ clearInterval(interval); } function start(){ interval = setInterval("clock()",1000); } function formatDate(date){ var year = date.getFullYear(); var month = change(date.getMonth()+1); var dd = change(date.getDate()); var hour = change(date.getHours()); var min = change(date.getMinutes()); var second = change(date.getSeconds()); return year + '-' + month + '-' + dd + ' ' + hour + ':' + min + ':' + second; } function change(num){ if(num < 10){ return "0" + num; } return num; } </script> </head> <body> <div id="div1"> sdfas </div> <input type="button" value="暂停" onclick="pause()" /> <input type="button" value="开始" onclick="start()" /> </body> </html> 输出： 4、js的Math对象 * 数学的运算 ** 里面的都是静态方法，使用可以直接使用 Math.方法() ** ceil(x): 向上舍人 ** floor(x)：向下舍人 ** round(x)：四舍五入 ** random()：得到随机数（伪随机数） - 得到0-9的随机数 Math.random()*10 Math.floor(Math.random()*10)); <!DOCTYPE html> <html> <head> <meta charset="UTF-8"> <title>对象</title> <script type="text/javascript"> var num = 5.0; for(var i = 0; i < 100; i ++){ document.write(Math.ceil(Math.random()*10)); document.write("<br />") } </script> </head> <body> </body> </html> 输出： 5、js的全局函数 * 由于不属于任何一个对象，直接写名称使用 ** eval() ： 执行js代码（如果字符串是一个js代码，使用方法直接执行） **** var str = "alert('1234');"; //alert(str); eval(str); ** isNaN():判断当前字符串是否是数字 -- var str2 = "aaaa"; alert(isNaN(str2)); *** 如果是数字，返回false *** 如果不是数字，返回true ** parseInt()：类型转换 ** var str3 = "123"; document.write(parseInt(str3)+1); 6、js的bom对象 ** bom：broswer object model: 浏览器对象模型 ** 包含对象： *** navigator： 获取客户机的信息（浏览器的信息） - navigator.appName - document.write(navigator.appName); *** screen: 获取屏幕的信息 - document.write(screen.width); document.write("<br/>"); document.write(screen.height); <!DOCTYPE html> <html> <head> <meta charset="UTF-8"> <title>对象</title> <script type="text/javascript"> document.write(navigator.appName); document.write(screen.width) ; document.write(screen.height) ; </script> </head> <body> </body> </html> 输出： *** location: 请求url地址 - href属性 **** 获取到请求的url地址 - document.write(location.href); **** 设置url地址 - 页面上安置一个按钮，按钮上绑定一个事件，当我点击这个按钮，页面可以跳转到另外一个页面 - location.href = "hello.html"; **** <input type="button" value="tiaozhuan" onclick="href1();"/> - 鼠标点击事件 onclick="js的方法;"案例：跳转到百度 <!DOCTYPE html> <html> <head> <meta charset="UTF-8"> <title>对象</title> <script type="text/javascript"> function tz(){ location.href = 'http://www.baidu.com'; } </script> </head> <body> <input type="button" value="跳转" onclick="tz()" /> </body> </html> 输出： *** history：请求的url的历史记录 - 创建三个页面 1、创建第一个页面 a.html 写一个超链接 到 b.html 2、创建b.html 超链接 到 c.html 3、创建c.html - 到访问的上一个页面 history.back(); history.go(-1); - 到访问的下一个页面 history.forward(); history.go(1); <!DOCTYPE html> <html> <head> <meta charset="UTF-8"> <title></title> <script type="text/javascript"> var ww ; function openWin(){ ww = open("aaa.html","","width=900,height=700"); } function closeWin(){ ww.close(); } </script> </head> <body> <input type="button" value="打开子窗口" onclick="openWin()"/> <input type="button" value="关闭子窗口" onclick="closeWin()"/> </body> </html> 输出： **** window（窗口对象） * 顶层对象（所用的bom对象都是在window里面操作的） ** 方法 - window.alert() : 页面弹出一个框，显示内容 ** 简写alert() - confirm()： 确认框 - var flag = window.confirm("显示的内容"); - open() : 打开一个新的窗口 ** open("打开的新窗口的地址url","","窗口特征，比如窗口宽度和高度") - 创建一个按钮，点击这个按钮，打开一个新的窗口 - window.open("hello.html","","width=200,height=100"); - close(): 关闭窗口(浏览器兼容性比较差) - window.close(); - 做定时器 ** setInterval("js代码",毫秒数) 1秒=1000毫秒 - 表示每三秒，执行一次alert方法 window.setInterval("alert('123');",3000); ** setTimeout("js代码",毫秒数) - 表示在毫秒数之后执行，但是只会执行一次 - 表示四秒之后执行js代码，只会执行一次 window.setTimeout("alert('abc');",4000); ** clearInterval(): 清除setInterval设置的定时器 var id1 = setInterval("alert('123');",3000);//通过setInterval会有一个返回值 clearInterval(id1); ** clearTimeout() : 清除setTimeout设置的定时器 var id2 = setTimeout("alert('abc');",4000); clearTimeout(id2); 9、document对象 * 表示整个的文档 ** 常用方法 **** write()方法： （1）向页面输出变量（值） （2）向页面输出html代码 - var str = "abc"; document.write(str); document.write("<hr/>"); **** getElementById(); - 通过id得到元素（标签） - //使用getElementById得到input标签 var input1 = document.getElementById("nameid"); //传递的参数是标签里面的id的值 //得到input里面的value值 alert(input1.name); //标签对象.属性名称 //向input里面设置一个值value input1.value = "bbbbb"; **** getElementsByName(); - 通过标签的name的属性值得到标签 - 返回的是一个集合（数组） - //使用getElementsByName得到input标签 var inputs = document.getElementsByName("name1"); //传递的参数是 标签里面的name的值 //alert(inputs.length); //遍历数组 for(var i=0;i<inputs.length;i++) { //通过遍历数组，得到每个标签里面的具体的值 var input1 = inputs[i]; //每次循环得到input对象，赋值到input1里面 alert(input1.value); //得到每个input标签里面的value值 } **** getElementsByTagName("标签名称"); - 通过标签名称得到元素 - //演示getElementsByTagName var inputs1 = document.getElementsByTagName("input"); //传递的参数，是标签名称 //alert(inputs1.length); //遍历数组，得到每个input标签 for(var m=0;m<inputs1.length;m++) { //得到每个input标签 var input1 = inputs1[m]; //得到value值 alert(input1.value); } **** 注意地方 **** 只有一个标签，这个标签只能使用name获取到，这个使用，使用getElementsByName返回的是一个数组， 但是现在只有一个元素，这个时候不需要遍历，而是可以直接通过数组的下标获取到值 //通过name得到input标签 var inputs2 = document.getElementsByName("name11")[0]; alert(inputs2.value); var inputss = document.getElementsByTagName("input")[0]; alert(inputss.value); 案例： <!DOCTYPE html> <html> <head> <meta charset="UTF-8"> <title></title> </head> <body> 用户名：<input type="text" id="username" /><br /> 密码：<input type="text" id="password" /><br /> 年龄：<input type="text" id="age" /><br /> 爱好： <input type="checkbox" name="lover" value="看书" />看书 <input type="checkbox" name="lover" value="篮球" />篮球 <input type="checkbox" name="lover" value="跑酷" />跑酷 <input type="checkbox" name="lover" value="游泳" />游泳 <input type="checkbox" name="lover" value="下棋" />下棋<br /> <input type="button" value="显示用户信息" onclick="showUserInfo()"/> <div id="showUserInfo" style="width:200px;height: 100px;border:5px dotted #000;"> </div> </body> </html> <script type="text/javascript"> function showUserInfo(){ var username = document.getElementById("username").value; var password = document.getElementById("password").value; var age = document.getElementById("age").value; var lovers = document.getElementsByName("lover"); var loverStr = ""; for(var i = 0; i < lovers.length; i++){ if(lovers[i].checked){ loverStr += lovers[i].value + "，"; } } loverStr = loverStr.substring(0,loverStr.length - 1); var showUi = document.getElementById("showUserInfo"); var str = "用户名：" + username + "<br/>" + "密码：" + password + "<br/>年龄：" + age; str += "<br>爱好：" + loverStr; showUi.innerHTML = str; } </script> 输出： 方法二： <!DOCTYPE html> <html> <head> <meta charset="UTF-8"> <title></title> </head> <body> 用户名：<input type="text" id="username" /><br /> 密码：<input type="text" id="password" /><br /> 年龄：<input type="text" id="age" /><br /> 爱好： <input type="checkbox" name="lover" value="看书" />看书 <input type="checkbox" name="lover" value="篮球" />篮球 <input type="checkbox" name="lover" value="跑酷" />跑酷 <input type="checkbox" name="lover" value="游泳" />游泳 <input type="checkbox" name="lover" value="下棋" />下棋<br /> <input type="button" value="显示input value属性值信息" onclick="showUserInfo()"/> <div id="showUserInfo" style="width:200px;height: 100px;border:5px dotted #000;"> </div> </body> </html> <script type="text/javascript"> function showUserInfo(){ var inputs = document.getElementsByTagName("input"); var showUserInfo = document.getElementById("showUserInfo"); for(var i = 0; i < inputs.length; i++){ showUserInfo.innerHTML += inputs[i].value + "&nbsp;&nbsp;"; } } </script> 输出：
2018-07-30
优秀的个人博客,低调大师

python基础3

1.函数基本语法及特性 函数是什么? 函数一词来源于数学，但编程中的「函数」概念，与数学中的函数是有很大不同的，具体区别，我们后面会讲，编程中的函数在英文中也有很多不同的叫法。在BASIC中叫做subroutine(子过程或子程序)，在Pascal中叫做procedure(过程)和function，在C中只有function，在Java里面叫做method。 定义: 函数是指将一组语句的集合通过一个名字(函数名)封装起来，要想执行这个函数，只需调用其函数名即可 特性: 减少重复代码 使程序变的可扩展 使程序变得易维护 定义: 1 def Hello():#函数名 2 print('Hello World!') 3 Hello()#调用函数 可以带参数: 1 def calc(x,y): 2 z = x*y 3 return z 4 c = calc(3,4) 5 print(c)#结果12 2.函数参数与局部变量 形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量 实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值 还是上面的代码: 1 def calc(x,y): #(x,y)为形参 2 z = x*y 3 return z 4 c = calc(a,b) #(a.b)为实参 5 print(c) 默认参数 1 def stu_register(name, age, country, course): 2 print("----注册学生信息------") 3 print("姓名:", name) 4 print("age:", age) 5 print("国籍:", country) 6 print("课程:", course) 7 8 9 stu_register("小丽", 22, "CN", "python_devops") 10 stu_register("小明", 21, "CN", "linux") 11 stu_register("小王", 25, "CN", "linux") 发现 country 这个参数 基本都 是"CN", 就像我们在网站上注册用户，像国籍这种信息，你不填写，默认就会是 中国， 这就是通过默认参数实现的，把country变成默认参数非常简单 所以,我们可以通过下面代码简化代码: def stu_register(name, age, course，country="CN"): 这样，这个参数在调用时不指定，那默认就是CN，默认你选的值，默认参数！ 注意：跟上一段代码比较，为什么默认参数放到后面呢？ 简单来讲就是会产生歧义。 不妨想一想，如果确实如你所说，有默认值的参数位于无默认值之前，则调用函数时就必须使用key=Value的形式，而不能使用直接送入Value的形式了。为了调用函数时可以更便捷地使用后者，而同时又不产生歧义，在定义函数时，无默认值参数就必须位于前面了。考虑到定义函数只要一次，调用函数可能是很多地方、很多人使用，定义函数时稍微注意点是可以理解的了。 关键参数 正常情况下，给函数传参数要按顺序，不想按顺序就可以用关键参数，只需指定参数名即可，但记住一个要求就是，关键参数必须放在位置参数之后。 关键字参数： 1 def tes(x=1,y=2): 2 print(x) 3 print(y) 4 tes() 位置参数: 1 def tet1(x,y): 2 print(x) 3 print(y) 4 tet1(1,2) 非固定参数： 若你的函数在定义时不确定用户想传入多少个参数，就可以使用非固定参数 #*args参数组,将位置参数(一一对应的位置)放到元组 def tes(*args): print(args) tes(1,2,34,5,6) ＃结果：(1, 2, 34, 5, 6) 还可以有一个**kwargs 1 def tes(**kwargs): 2 print(kwargs) 3 tes(name='young',age='23',sex='1') 将上述几个参数组合: 1 def tes(name,age=23,*args,**kwargs): 2 print(name) 3 print(age) 4 print(args) 5 print(kwargs) 6 tes('young',3,5,6,sex='man',job='IT') 7 ''' 8 结果: 9 young 10 3 11 (5, 6) 12 {'sex': 'man', 'job': 'IT'} 13 ''' 局部变量: 1 name = "哈哈" 2 3 def change_name(name): 4 print("before:", name) 5 name = "Young" 6 print("after", name) 7 8 change_name(name) 9 print("真的改了吗?", name) 输出: before: 哈哈 after Young 真的改了吗? 哈哈 可以通过global来实现 1 name = "哈哈" 2 3 def change_name(obj): 4 global name 5 print("before:", name) 6 name = "Young" 7 print("after", name) 8 9 change_name(name) 10 print("确实改了!", name) 输出: before: 哈哈 after Young 确实改了! Young 全局与局部变量 在子程序中定义的变量称为局部变量，在程序的一开始定义的变量称为全局变量。 全局变量作用域是整个程序，局部变量作用域是定义该变量的子程序。 当全局变量与局部变量同名时： 在定义局部变量的子程序内，局部变量起作用；在其它地方全局变量起作用 3.返回值 要想获取函数的执行结果，就可以用return语句把结果返回 注意: 函数在执行过程中只要遇到return语句，就会停止执行并返回结果，so 也可以理解为 return 语句代表着函数的结束 如果未在函数中指定return,那这个函数的返回值为None 嵌套函数: python允许在定义函数的时候，其函数体内又包含另外一个函数的完整定义，这就是我们通常所说的嵌套定义。为什么？因为函数是用def语句定义的，凡是其他语句可以出现的地方，def语句同样可以出现。像这样定义在其他函数内的函数叫做内部函数，内部函数所在的函数叫做外部函数。当然，我们可以多层嵌套，这样的话，除了最外层和最内层的函数之外，其它函数既是外部函数又是内部函数。 1 spam = 99 2 def tester(): 3 def nested(): 4 global spam 5 print('current=',spam) 6 spam += 1 7 return nested 8 #注意：打印 print 那行的代码调用是tester()() 9 #而不是tester().nested() 4.递归 在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。 1 def calc(n): 2 print(n) 3 if int(n/2)>0: 4 return calc(int(n/2)) 5 print("->",n) 6 calc(10) 输出: 1 10 2 5 3 2 4 1 5 -> 1 递归特性: 1. 必须有一个明确的结束条件 2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少 3. 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出） 堆栈相关知识:http://www.cnblogs.com/lln7777/archive/2012/03/14/2396164.html 递归实例, 二分查找: 1 data = [1, 3, 6, 7, 9, 12, 14, 16, 17, 18, 20, 21, 22, 23, 30, 32, 33, 35] 2 3 4 def binary_search(dataset,find_num): 5 print(dataset) 6 7 if len(dataset) >1: 8 mid = int(len(dataset)/2) 9 if dataset[mid] == find_num: #find it 10 print("找到数字",dataset[mid]) 11 elif dataset[mid] > find_num :# 找的数在mid左面 12 print("\033[31;1m找的数在mid[%s]左面\033[0m" % dataset[mid]) 13 return binary_search(dataset[0:mid], find_num) 14 else:# 找的数在mid右面 15 print("\033[32;1m找的数在mid[%s]右面\033[0m" % dataset[mid]) 16 return binary_search(dataset[mid+1:],find_num) 17 else: 18 if dataset[0] == find_num: #find it 19 print("找到数字啦",dataset[0]) 20 else: 21 print("没的分了,要找的数字[%s]不在列表里" % find_num) 22 23 24 binary_search(data,66) View Code 5.匿名函数 匿名函数就是不需要显式的指定函数 1 def calc(n): 2 return n ** n 3 print(calc(3)) 4 # 换成匿名函数 5 calc = lambda n: n ** n 6 print(calc(3)) 匿名函数主要是和其它函数搭配使用的: res = map(lambda x:x**2,[1,2,3,4,5]) for i in res: print(i) 输出: 1 4 9 16 25 6.函数式编程介绍 函数是Python内建支持的一种封装，我们通过把大段代码拆成函数，通过一层一层的函数调用，就可以把复杂任务分解成简单的任务，这种分解可以称之为面向过程的程序设计。函数就是面向过程的程序设计的基本单元。 函数式编程中的函数这个术语不是指计算机中的函数（实际上是Subroutine），而是指数学中的函数，即自变量的映射。也就是说一个函数的值仅决定于函数参数的值，不依赖其他状态。比如sqrt(x)函数计算x的平方根，只要x不变，不论什么时候调用，调用几次，值都是不变的。 Python对函数式编程提供部分支持。由于Python允许使用变量，因此，Python不是纯函数式编程语言。 一、定义 简单说，"函数式编程"是一种"编程范式"（programming paradigm），也就是如何编写程序的方法论。 主要思想是把运算过程尽量写成一系列嵌套的函数调用。举例来说，现在有这样一个数学表达式： (1 + 2) * 3 - 4 传统的过程式编程，可能这样写： var a = 1 + 2; var b = a * 3; var c = b - 4; 函数式编程要求使用函数，我们可以把运算过程定义为不同的函数，然后写成下面这样： var result = subtract(multiply(add(1,2), 3), 4); 这段代码再演进以下，可以变成这样 add(1,2).multiply(3).subtract(4) 这基本就是自然语言的表达了。再看下面的代码，大家应该一眼就能明白它的意思吧： merge([1,2],[3,4]).sort().search("2") 因此，函数式编程的代码更容易理解。 7.高阶函数 变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。 def add(a,b,f): return f(a)+f(b) res = add(2,-3,abs) print(res) 8.内置参数 内置参数详解 https://docs.python.org/3/library/functions.html?highlight=built#ascii 几个内置方法用法提醒: #compile f = open("函数递归.py") data =compile(f.read(),'','exec') exec(data) #print msg = "又回到最初的起点" f = open("tofile","w") print(msg,"记忆中你青涩的脸",sep="|",end="",file=f) # #slice # a = range(20) # pattern = slice(3,8,2) # for i in a[pattern]: #等于a[3:8:2] # print(i) # # #memoryview #usage: #>>> memoryview(b'abcd') #<memory at 0x104069648> #在进行切片并赋值数据时，不需要重新copy原列表数据，可以直接映射原数据内存， import time for n in (100000, 200000, 300000, 400000): data = b'x'*n start = time.time() b = data while b: b = b[1:] print('bytes', n, time.time()-start) for n in (100000, 200000, 300000, 400000): data = b'x'*n start = time.time() b = memoryview(data) while b: b = b[1:] print('memoryview', n, time.time()-start) View Code
2018-07-12
优秀的个人博客,低调大师

python基础2

1.列表元组 列表是我们最以后最常用的数据类型之一，通过列表可以对数据实现最方便的存储、修改等操作. 定义列表: 1 # yu 2 3 names=["啦啦","嘿嘿",'鱼鱼'] 我们通过列表下标进行数据的提取: 1 # yu 2 names=["啦啦","嘿嘿",'鱼鱼'] 3 print(names) 4 print(names[0])#第一个数据从0开始 5 print(names[-1])#倒过来取值 切片: 1 # yu 2 names=["lala","heihei",'yuyu','hehe','haha'] 3 print(names[1:3])#取下标1 ,不包含下标3 ['heihei', 'yuyu'] 4 print(names[1:-1])#取下标1至-1的值，不包括-1 5 print(names[:3])#如果是从头开始取，0可以忽略 6 print(names[3:])#取到最后一个值 7 print(names[3:-1])#取不到最后一个值 8 print(names[0::2])#后面的2是代表，每隔一个元素，就取一个 View Code 追加: 1 # yu 2 names=["lala","heihei",'yuyu','hehe','haha'] 3 names.append("嘻嘻") 4 print(names) 5 #结果['lala', 'heihei', 'yuyu', 'hehe', 'haha', '嘻嘻'] View Code 插入: 1 # yu 2 names=["lala","heihei",'yuyu','hehe','haha'] 3 names.insert(2,'从2插入') 4 print(names) 5 #结果['lala', 'heihei', '从2插入', 'yuyu', 'hehe', 'haha'] View Code 修改: 1 # yu 2 names=["lala","heihei",'yuyu','hehe','haha'] 3 names[1]='修改下标为1' 4 print(names) 5 #结果['lala', '修改下标为1', '从2插入', 'yuyu', 'hehe', 'haha'] View Code 删除: 1 names=["lala","heihei",'yuyu','hehe','haha'] 2 #names.clear()#清空列表 3 print(names)#返回[] 4 #del names[1]#删除指定下标的值 5 print(names)#['lala', 'yuyu', 'hehe', 'haha' 6 #names.remove("yuyu")#删除指定的值 7 print(names) 8 names.pop()#默认删最后一个,也可以加入你祥删除的下标 9 print(names) View Code 扩展: 1 # yu 2 names=["lala","heihei",'yuyu','hehe','haha'] 3 b=[1,2,3] 4 names.extend(b) 5 print(names)#['lala', 'heihei', 'yuyu', 'hehe', 'haha', 1, 2, 3] View Code 拷贝(浅拷贝与深拷贝的区别): 1 names=["Young","Jon",["Tom","Jerry"],'Jems','Sunny'] 2 names2 = names.copy() 3 names[1]="浅copy" 4 names[2][0]="深copy" 5 print('name1:',names) 6 print('name2:',names2) 7 #结果 8 #name1: ['Young', '浅copy', ['深copy', 'Jerry'], 'Jems', 'Sunny'] 9 #name2: ['Young', 'Jon', ['深copy', 'Jerry'], 'Jems', 'Sunny'] View Code 统计: 1 # yu 2 names=["lala","heihei",'yuyu','hehe','haha','haha'] 3 print(names.count('haha'))#结果2 View Code 排序: 1 # yu 2 names=["1lala","3heihei",'5yuyu','4hehe','2haha','1haha'] 3 names.sort() 4 print(names) View Code 反转: 1 names=["1lala","2heihei",'3yuyu','4hehe','5haha','6haha'] 2 names.reverse() 3 print(names) 4 #结果['6haha', '5haha', '4hehe', '3yuyu', '2heihei', '1lala'] View Code 获取下标: 1 # yu 2 names=["0lala","1heihei",'2yuyu','3hehe','4haha','5haha'] 3 print(names.index("2yuyu"))#2 View Code 元组 元组其实跟列表差不多，也是存一组数，只不是它一旦创建，便不能再修改，所以又叫只读列表 定义: names=("lala","heihei",'yuyu','hehe','haha','haha') 它只有2个方法，一个是count,一个是index. 2.字符串操作 特性;不可修改. # yu name='young' #首字母大写 print(name.capitalize() ) # name.casefold() 大写全部变小写 print(name.center(50,"-") ) #输出----------------------young----------------------- # name.count('lex') 统计 lex出现次数 # name.encode() 将字符串编码成bytes格式 # name.endswith("g") 判断字符串是否以g结尾 # "Young\tY".expandtabs(10) 输出'Young Y'， 将\t转换成多长的空格 print(name.find('o')) #查找A,找到返回其索引， 找不到返回-1 1 #format 2 cata = "my name is {}, and age is {}" 3 print(cata.format("young",23))#结果my name is young, and age is 23 4 cata = "my name is {}, and age is {}" 5 print(cata.format("23",'young'))#my name is 23, and age is young 6 cata = "my name is {name}, and age is {age}" 7 print(cata.format(age=23,name='young')) 8 9 #format_map 10 cata = "my name is {name}, and age is {age}" 11 print(cata.format_map({'name':'young','age':23})) View Code cata = "my name is {name}, and age is {age}" print(cata.index('a')) print('9aA'.isalnum() ) print('9'.isdigit() )#是否整数) name='Hello' print(name.isnumeric ) # name.isprintable # name.isspace # name.istitle # name.isupper print("|".join(['lala','hihi','wow'])) View Code #maketrans intab = "aeiou" #This is the string having actual characters. outtab = "12345" #This is the string having corresponding mapping character trantab = str.maketrans(intab, outtab) print(trantab) str = "this is string example....wow!!!" print(str.translate(trantab)) # 'th3s 3s str3ng 2x1mpl2....w4w!!!' View Code 1 print(cata.partition('is'))#('my name ', 'is', ' {name}, and age is {age}') 2 print(cata.swapcase())#大小写互换 3 print(cata.zfill(40)) 4 n='hello world' 5 print(n.ljust(40, "-")) 6 print(n.rjust(40, "-")) 7 b="ddefdsdff_哈哈" 8 b.isidentifier() #检测一段字符串可否被当作标志符，即是否符合变量命名规则 View Code 3.字典操作 字典一种key - value 的数据类型. 定义: info = { "1":"嘻嘻", "2":"哈哈", "3":"呵呵", "4":"嘿嘿" } 字典的特性： dict是无序的 key必须是唯一的 增删改查: #增 info["5"]="哇哇" #改 info["1"]="么么" print(info) #删 info.pop("1") #del info["1"] #info.popitem()#随机删除 #查 print("3" in info) print(info["3"]) print(info.get("2")) print(info) View Code 其他方法: print(info.keys()) print(info.values()) info2 = { "5":'啦啦', '6':'哼哼' } info.update(info2) print(info) print(info.setdefault("1","大少")) print(info.items()) View Code 循环dict: #两种方法: for key in info: print(key,info[key]) for k,v in info.items(): print(k,v) View Code 三级菜单: 打印省、市、县三级菜单 可返回上一级 可随时退出程序 data = { '黑龙江':{ "哈尔滨":{ "南岗":["凯德","许乐会所"], "松北":["君慕稀","大保健"] }, "牡丹江":{ "镜泊湖":["大山","河流"], "好地方":{"优美","地灵"}, "小城":{"故事","美好"}, }, "海淀":{}, }, '山东':{ "德州":{}, "青岛":{}, "济南":{} }, '广东':{ "东莞":{}, "常熟":{}, "佛山":{}, }, } exit_flag = False while not exit_flag: for i in data: print(i) choice = input(">>选择进入1") if choice in data: while not exit_flag: for i2 in data[choice]: print("\t",i2); choice2 = input(">>选择进入2") if choice2 in data[choice]: while not exit_flag: for i3 in data[choice][choice2]: print("\t\t", i3); choice3 = input(">>选择进入3") if choice3 in data[choice][choice2]: for i4 in data[choice][choice2][choice3]: print("\t\t", i4); choice4 =input("最后一次,按b返回") if choice4 =="b": pass elif choice4 =="q": exit_flag=True; if choice3 == "b": break elif choice3 == "q": exit_flag = True; if choice2 == "b": break elif choice2 == "q": exit_flag = True; View Code 4.集合操作 集合是一个无序的，不重复的数据组合，它的主要作用如下： 去重，把一个列表变成集合，就自动去重了 关系测试，测试两组数据之前的交集、差集、并集等关系 常用操作: #定义一个集合 list1=[1,23,4,5,6,0] list1 =set(list1) list2=set([1,2,7,8,9,0]) ''' print (list1) print(list2) #交集 print(list1.intersection(list2)) print(list1 & list2) #并集 print(list1.union(list2)) print(list1 | list2) #差集 print(list1.difference(list2)) print(list1 - list2) #子集 list3 = set([1,2,3,4]) list4 = set([1,2]) list5 = set([0,9]) print(list4.issubset(list3)) print(list3.issuperset(list4)) #对称差集 print(list1.symmetric_difference(list2)) print("-----------------------") print(list3.isdisjoint(list5))#看有没有交集,并返回true or false; ''' #添加,没有插入 list1.add(12) print(list1) #删 print(list1.pop()) print(list1.pop()) print(list1) list1.discard(23) print(list1) View Code 5.文件操作 对文件操作流程 打开文件，得到文件句柄并赋值给一个变量 通过句柄对文件进行操作 关闭文件 文件text: 晚风轻拂着澎湖湾 白浪逐沙滩 没有椰林醉斜阳 只是一片海蓝蓝 坐在门前的矮墙上一遍遍幻想 也是黄昏的沙滩上有着脚印两对半 那是外婆拄着杖将我手轻轻挽 踩着薄暮走向余晖暖暖的澎湖湾 一个脚印是笑语一串消磨许多时光 直到夜色吞没我俩在回家的路上 澎湖湾澎湖湾外婆的澎湖湾 有我许多的童年幻想 阳光沙滩海浪仙人掌 还有一位老船长 View Code 基本操作: 1 f = open("外婆的澎湖湾",encoding='utf-8')#文件句柄, 2 # f.write("hello world\n".encode()) 3 f1 = f.readline() 4 print('first line:',f1) 5 print('我是分隔线'.center(50,'-')) 6 data = f.read()# 读取剩下的所有内容,文件大时不要用 7 print(data) #打印文件 8 f.close() View Code 打开文件的模式有： r，只读模式（默认）。 w，只写模式。【不可读；不存在则创建；存在则删除内容；】 a，追加模式。【可读； 不存在则创建；存在则只追加内容；】 "+" 表示可以同时读写某个文件 r+，可读写文件。【可读；可写；可追加】 w+，写读 a+，同a "U"表示在读取时，可以将 \r \n \r\n自动转换成 \n （与 r 或 r+ 模式同使用） rU r+U "b"表示处理二进制文件（如：FTP发送上传ISO镜像文件，linux可忽略，windows处理二进制文件时需标注） rb wb ab with语句 为了避免打开文件后忘记关闭，可以通过管理上下文，即： 1 with open('外婆的澎湖湾','r') as f: 2 3 ... 如此方式，当with代码块执行完毕时，内部会自动关闭并释放文件资源。 在Python 2.7 后，with又支持同时对多个文件的上下文进行管理，即： 1 with open('log1') as obj1, open('log2') as obj2: 2 pass 6.字符的编码与转码 参考文章: http://www.cnblogs.com/yuanchenqi/articles/5956943.html 需知: 1.在python2默认编码是ASCII, python3里默认是unicode 2.unicode 分为 utf-32(占4个字节),utf-16(占两个字节)，utf-8(占1-4个字节)， so utf-16就是现在最常用的unicode版本， 不过在文件里存的还是utf-8，因为utf8省空间 3.在py3中encode,在转码的同时还会把string 变成bytes类型，decode在解码的同时还会把bytes变回string python3中: 1 import sys 2 print(sys.getdefaultencoding()) 3 s = "你好" 4 5 s_gbk = s.encode("gbk") 6 7 print(s_gbk)#gbk 8 9 print(s.encode())#utf8 10 11 gbk_to_utf8 = s_gbk.decode("gbk").encode("utf-8") 12 print(gbk_to_utf8) View Code
2018-07-08
优秀的个人博客,低调大师

Java基础题

List和Set比较，各自的子类比较 对比一：Arraylist与LinkedList的比较 1、ArrayList是实现了基于动态数组的数据结构,因为地址连续，一旦数据存储好了，查询操作效率会比较高（在内存里是连着放的）。 2、因为地址连续， ArrayList要移动数据,所以插入和删除操作效率比较低。 3、LinkedList基于链表的数据结构,地址是任意的，所以在开辟内存空间的时候不需要等一个连续的地址，对于新增和删除操作add和remove，LinedList比较占优势。 4、因为LinkedList要移动指针,所以查询操作性能比较低。 适用场景分析： 当需要对数据进行对此访问的情况下选用ArrayList，当需要对数据进行多次增加删除修改时采用LinkedList。 对比二：ArrayList与Vector的比较 1、Vector的方法都是同步的，是线程安全的，而ArrayList的方法不是，由于线程的同步必然要影响性能。因此，ArrayList的性能比Vector好。 2、当Vector或ArrayList中的元素超过它的初始大小时，Vector会将它的容量翻倍，而ArrayList只增加50%的大小，这样。ArrayList就有利于节约内存空间。 3、大多数情况不使用Vector，因为性能不好，但是它支持线程的同步，即某一时刻只有一个线程能够写Vector，避免多线程同时写而引起的不一致性。 4、Vector可以设置增长因子，而ArrayList不可以。 适用场景分析： 1、Vector是线程同步的，所以它也是线程安全的，而ArrayList是线程异步的，是不安全的。如果不考虑到线程的安全因素，一般用ArrayList效率比较高。 2、如果集合中的元素的数目大于目前集合数组的长度时，在集合中使用数据量比较大的数据，用Vector有一定的优势。 对比三：HashSet与TreeSet的比较 1.TreeSet 是二叉树实现的，Treeset中的数据是自动排好序的，不允许放入null值 。 2.HashSet 是哈希表实现的，HashSet中的数据是无序的，可以放入null，但只能放入一个null，两者中的值都不能重复，就如数据库中唯一约束 。 3.HashSet要求放入的对象必须实现HashCode()方法，放入的对象，是以hashcode码作为标识的，而具有相同内容的String对象，hashcode是一样，所以放入的内容不能重复。但是同一个类的对象可以放入不同的实例。 适用场景分析： HashSet是基于Hash算法实现的，其性能通常都优于TreeSet。我们通常都应该使用HashSet，在我们需要排序的功能时，我们才使用TreeSet。 大体回答如上，类似文章请移驾： List,Set和Map详解及其区别和他们分别适用的场景 HashMap和ConcurrentHashMap的区别 1、HashMap不是线程安全的，而ConcurrentHashMap是线程安全的。 2、ConcurrentHashMap采用锁分段技术，将整个Hash桶进行了分段segment，也就是将这个大的数组分成了几个小的片段segment，而且每个小的片段segment上面都有锁存在，那么在插入元素的时候就需要先找到应该插入到哪一个片段segment，然后再在这个片段上面进行插入，而且这里还需要获取segment锁。 3、ConcurrentHashMap让锁的粒度更精细一些，并发性能更好。 大体回答如上，类似文章请移驾： HashMap详解 至于两者的底层实现，你如果想通过一篇文章就理解了，那就too young了，好好找些博文+看源码去吧。 HashTable和ConcurrentHashMap的区别 它们都可以用于多线程的环境，但是当Hashtable的大小增加到一定的时候，性能会急剧下降，因为迭代时需要被锁定很长的时间。因为ConcurrentHashMap引入了分割(segmentation)，不论它变得多么大，仅仅需要锁定map的某个部分，而其它的线程不需要等到迭代完成才能访问map。简而言之，在迭代的过程中，ConcurrentHashMap仅仅锁定map的某个部分，而Hashtable则会锁定整个map。 大体回答如上，类似文章请移驾： HashMap和HashTable到底哪不同？ String,StringBuffer和StringBuilder的区别 1、运行速度，或者说是执行速度，在这方面运行速度快慢为：StringBuilder > StringBuffer > String。 2、线程安全上，StringBuilder是线程不安全的，而StringBuffer是线程安全的。 适用场景分析： String：适用于少量的字符串操作的情况 StringBuilder：适用于单线程下在字符缓冲区进行大量操作的情况 StringBuffer：适用多线程下在字符缓冲区进行大量操作的情况 大体回答如上，类似文章请移驾： String、StringBuffer与StringBuilder介绍 wait和sleep的区别 1、sleep()方法是属于Thread类中的，而wait()方法，则是属于Object类中的。 2、sleep()方法导致了程序暂停执行指定的时间，让出cpu给其他线程，但是他的监控状态依然保持着，当指定的时间到了又会自动恢复运行状态。所以在调用sleep()方法的过程中，线程不会释放对象锁。 3、调用wait()方法的时候，线程会放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象调用notify()方法后本线程才进入对象锁定池准备获取对象锁进入运行状态。 转载：阿木侠芋道源码 https://mp.weixin.qq.com/s?__biz=MzUzMTA2NTU2Ng==&mid=2247484399&idx=1&sn=498a9f0151541d7c3bad2ebccb9aaa2f&chksm=fa497c5ecd3ef5488e6c4cddb24df96725b6147b99bbd485aa1f2c0ddb5d5604ef30026fad0d&key=de1ccb5f17d36506c921d919664438825a1235a753e24a11b1ce3a031c7b378e28090b3fdcffd4b73edbaaeb6562b6f280d4bc67a57e6cb626ac516e2eb54ccf7e5aef241c5043778c8fc78b26d0d479&ascene=0&uin=MTE1MDEyOTYwMA%3D%3D&devicetype=iMac+MacBookPro13%2C1+OSX+OSX+10.12.4+build(16E195)&version=12020810&nettype=WIFI&lang=zh_CN&fontScale=100&pass_ticket=8hfanWIrVdtZ6JsIT2zjCOessVLBtelL6wU308J%2FGjCOe3Il9eKp%2BWWn70JiqUCX
2018-06-13

资源下载

更多资源
优质分享App

优质分享App

近一个月的开发和优化，本站点的第一个app全新上线。该app采用极致压缩，本体才4.36MB。系统里面做了大量数据访问、缓存优化。方便用户在手机上查看文章。后续会推出HarmonyOS的适配版本。

时间: 2025-12-03 大小: 4.36MB 下载: 23次
腾讯云软件源

腾讯云软件源

为解决软件依赖安装时官方源访问速度慢的问题，腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构，目前腾讯云软件源站支持公网访问和内网访问。

时间: 2026-01-27 大小: 1MB 下载: 5次
Nacos

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

时间: 2025-12-21 大小: 189MB 下载: 2次
Rocky Linux

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。

时间: 2026-01-03 大小: 1.42GB 下载: 2次
热门标签
SpringBoot4 Service Mesh Redis DeepSeek Jdk25 Kubernetes HarmonyOS6 Gemini3 Docker Rocky Nacos3 OpenAi SpringCloud

欢迎您来访！

登录后，您将获得更多功能！
热门文章
联系我们

有任何问题或合作意向欢迎联系我们

Email: 99873273@qq.com

QQ: 99873273

用户登录
用户注册