I need a good explanation (references are a plus) on Python slicing.

Understanding slicing

Why do I get an error of &quot;can&#39;t multiply sequence by non-int of type &#39;float&#39;&quot;? from the following code:


    def nestEgVariable(salary, save, growthRates):
        SavingsRecord = []
        fund = 0
        depositPerYear = salary * save * 0.01
        for i in growthRates:  
            fund = fund * (1 + 0.01 * growthRates) + depositPerYear
            SavingsRecord += [fund,]
        return SavingsRecord 
    
    
    print nestEgVariable(10000,10,[3,4,5,0,3])


can&#39;t multiply sequence by non-int of type &#39;float&#39;

There&#39;s something I don&#39;t understand about Scala&#39;s [`collection.mutable.Seq`](http://www.scala-lang.org/api/current/index.html#scala.collection.mutable.Seq). It describes the interface for all mutable sequences, yet I don&#39;t see methods to append or prepend elements without creating a new sequence. Am I missing something obvious here?

There are `:+` and `+:` for append and prepend, respectively, but they create new collections — in order to be consistent with the behavior of immutable sequences, I assume. This is fine, but why is there no method like `+=` and `+=:`, like `ArrayBuffer` and `ListBuffer` define, for in-place append and prepend? Does it mean that I cannot refer to a mutable seq that&#39;s typed as `collection.mutable.Seq` if I want to do in-place append?

Again, I must have missed something obvious, but cannot find what…

How to append or prepend on a Scala mutable.Seq

Is there any way to get the functionality of the Sql Server 2005+ Sequential Guid generator without inserting records to read it back on round trip or invoking a native win dll call? I saw someone answer with a way of using rpcrt4.dll but I&#39;m not sure if that would be able to work from my hosted environment for production.


**Edit:** Working with @John Boker&#39;s answer I attempted to turn it into more of a GuidComb generator instead of being dependent on the last generated Guid other than starting over. That for the seed instead of starting with Guid.Empty that I use

    public SequentialGuid()
    {
        var tempGuid = Guid.NewGuid();
        var bytes = tempGuid.ToByteArray();
        var time = DateTime.Now;
        bytes[3] = (byte) time.Year;
        bytes[2] = (byte) time.Month;
        bytes[1] = (byte) time.Day;
        bytes[0] = (byte) time.Hour;
        bytes[5] = (byte) time.Minute;
        bytes[4] = (byte) time.Second;
        CurrentGuid = new Guid(bytes);
    }

I based that off the comments on


    // 3 - the least significant byte in Guid ByteArray 
            [for SQL Server ORDER BY clause]
    // 10 - the most significant byte in Guid ByteArray 
            [for SQL Server ORDERY BY clause]
    SqlOrderMap = new[] {3, 2, 1, 0, 5, 4, 7, 6, 9, 8, 15, 14, 13, 12, 11, 10};

Does this look like the way I&#39;d want to seed a guid with the DateTime or does it look like I should do it in reverse and work backwards from the end of the SqlOrderMap indexes? I&#39;m not too concerned about their being a paging break anytime an initial guid would be created since it would only occur during application recycles.

**Edit: 2020+ update**

At this point I strongly prefer Snowflake identifiers using something like https://github.com/RobThree/IdGen

Sequential Guid Generator

As documented in both [Array][1] and [Dictionary][2] `forEach(_:)` Instance methods:

&gt; Calls the given closure on each element in the **sequence** in the same
&gt; order as a for-in loop.

Nevertheless, adapted from [Sequence Overview][3]:

&gt; A sequence is a list of values that you can step through one at a
&gt; time. *The most common way* to iterate over the elements of a sequence
&gt; is to use a **for-in loop**.

Implying that iterating sequence by `forEach(_:)` or `for in`:

    let closedRange = 1...3
    
    for element in closedRange { print(element) } // 1 2 3
    
    closedRange.forEach { print($0) } // 1 2 3

Or (Array):

    let array = [1, 2, 3]
    
    for element in array { print(element) } // 1 2 3
    
    array.forEach { print($0) } // 1 2 3

Would gives the same output.

Why `forEach(_:)` even exist? i.e what is the benefit of using it instead of the `for in` loop? would they be the same from performance point view?

As an assumption, it could be a syntactic sugar especially when working with *functional programming*.

  [1]: https://developer.apple.com/documentation/swift/array/1689783-foreach
  [2]: https://developer.apple.com/documentation/swift/dictionary/1689593-foreach
  [3]: https://developer.apple.com/documentation/swift/sequence

When to use forEach(_:) instead of for in?

Is it possible to use subqueries within alter expressions in PostgreSQL?

I want to alter a sequence value based on a primary key column value.

I tried using the following expression, but it wouldn&#39;t execute.

    alter sequence public.sequenceX restart with (select max(table_id)+1 from table)

Postgresql - Using subqueries with alter sequence expressions

Very simple example - one table, one index, one query:

    CREATE TABLE book
    (
      id bigserial NOT NULL,
      &quot;year&quot; integer,
      -- other columns...
    );

    CREATE INDEX book_year_idx ON book (year)

    EXPLAIN
     SELECT *
       FROM book b
      WHERE b.year &gt; 2009

gives me:

    Seq Scan on book b  (cost=0.00..25663.80 rows=105425 width=622)
      Filter: (year &gt; 2009)

Why it does NOT perform index scan instead?
What am I missing?

Why does PostgreSQL perform sequential scan on indexed column?

In [PostgreSQL][1], I can do something like this:

    ALTER SEQUENCE serial RESTART WITH 0;

Is there an Oracle equivalent?

  [1]: http://en.wikipedia.org/wiki/PostgreSQL


How do I reset a sequence in Oracle?

Is there an SQL instruction to retrieve the value of a sequence that does not increment it.

Thanks.

**EDIT AND CONCLUSION** 

As stated by Justin Cave It&#39;s not useful to try to &quot;save&quot; sequence number so


    select a_seq.nextval from dual;

is good enough to check a sequence value.

I still keep Ollie answer as the good one because it answered the initial question. but ask yourself about the necessity of not modifying the sequence if you ever want to do it.



How to retrieve the current value of an oracle sequence without increment it?

I have a table with over million rows. I need to reset sequence and reassign id column with new values (1, 2, 3, 4... etc...). Is any easy way to do that?

How to reset sequence in postgres and fill id column with new data?

In Python, the only way I can find to concatenate two lists is `list.extend`, which modifies the first list. Is there any concatenation function that returns its result without modifying its arguments?

How can I get the concatenation of two lists in Python without modifying either one?

Is it possible to use a DB sequence for some column that **is not the identifier/is not part of a composite identifier**? 

I&#39;m using hibernate as jpa provider, and I have a table that has some columns that are generated values (using a sequence), although they are not part of the identifier.

What I want is to use a sequence to create a new value for an entity, where the column for the sequence is **NOT** (part of) the primary key:

    @Entity
    @Table(name = &quot;MyTable&quot;)
    public class MyEntity {
    
        //...
        @Id //... etc
        public Long getId() {
            return id;
        }
        
       //note NO @Id here! but this doesn&#39;t work...
        @GeneratedValue(strategy = GenerationType.AUTO, generator = &quot;myGen&quot;)
        @SequenceGenerator(name = &quot;myGen&quot;, sequenceName = &quot;MY_SEQUENCE&quot;)
        @Column(name = &quot;SEQ_VAL&quot;, unique = false, nullable = false, insertable = true, updatable = true)
        public Long getMySequencedValue(){
          return myVal;
        }
    
    }

Then when I do this:

    em.persist(new MyEntity());

the id will be generated, but the `mySequenceVal` property will be also generated by my JPA provider.

Just to make things clear: I want **Hibernate** to generate the value for the `mySequencedValue` property. I know Hibernate can handle database-generated values, but I don&#39;t want to use a trigger or any other thing other than Hibernate itself to generate the value for my property. If Hibernate can generate values for primary keys, why can&#39;t it generate for a simple property?

Hibernate JPA Sequence (non-Id)

Data:
```R
df &lt;- data.frame(
    type   = c(&quot;T&quot;, &quot;F&quot;, &quot;P&quot;, &quot;T&quot;, &quot;F&quot;, &quot;P&quot;, &quot;T&quot;, &quot;F&quot;, &quot;P&quot;, &quot;T&quot;, &quot;F&quot;, &quot;P&quot;), 
    size   = c(&quot;50%&quot;, &quot;50%&quot;, &quot;50%&quot;, &quot;100%&quot;, &quot;100%&quot;, &quot;100%&quot;, &quot;150%&quot;, &quot;150%&quot;, &quot;150%&quot;, &quot;200%&quot;, &quot;200%&quot;, &quot;200%&quot;),
    amount = c(48.4, 48.1, 46.8, 25.9, 26, 24.9, 21.1, 21.4, 20.1, 20.8, 21.5, 16.5)
)
```

	

I need to plot a bargraph of the above data using ggplot (x-axis -&gt; `type`, y-axis -&gt; `amount`, group by `size`). When I used the following code, I am not getting the variable `type` and as well as `size` in the order shown in the data. Please see the figure. I have used the following code for that. 

     ggplot(df, aes(type, amount , fill=type, group=type, shape=type, facets=size)) + 
      geom_col(width=0.5, position = position_dodge(width=0.6)) + 
      facet_grid(.~size) + 
      theme_bw() + 
      scale_fill_manual(values = c(&quot;darkblue&quot;,&quot;steelblue1&quot;,&quot;steelblue4&quot;), 
                        labels = c(&quot;T&quot;, &quot;F&quot;, &quot;P&quot;))

![enter image description here][1] .

For fixing the order issue, I have used a factor method for the variable &quot;type&quot; using the following. Please see the figure also.

    temp$new = factor(temp$type, levels=c(&quot;T&quot;,&quot;F&quot;,&quot;P&quot;), labels=c(&quot;T&quot;,&quot;F&quot;,&quot;P&quot;)) 

![enter image description here][2]

However, now I don&#39;t know how to fix the order for the variable `size`. It should be 50%, 100%. 150%, and 200%.


  [1]: http://i.stack.imgur.com/bPkne.png
  [2]: http://i.stack.imgur.com/qNHnv.png


Fixing the order of facets in ggplot

F# has *sequences* that allows to create sequences:

    seq { 0 .. 10 }

Create sequence of numbers from 0 to 10.

Is there something similar in C#?

How to create a sequence of integers in C#?

I have the data.frame below. I want to add a column &#39;g&#39; that classifies my data according to consecutive sequences in column `h_no`. That is, the first sequence of h_no `1, 2, 3, 4` is group 1, the second series of `h_no` (1 to 7) is group 2, and so on, as indicated in the last column &#39;g&#39;.

    h_no   h_freq    h_freqsq g
    1     0.09091 0.008264628 1
    2     0.00000 0.000000000 1
    3     0.04545 0.002065702 1
    4     0.00000 0.000000000 1  
    1     0.13636 0.018594050 2
    2     0.00000 0.000000000 2
    3     0.00000 0.000000000 2
    4     0.04545 0.002065702 2
    5     0.31818 0.101238512 2
    6     0.00000 0.000000000 2
    7     0.50000 0.250000000 2 
    1     0.13636 0.018594050 3 
    2     0.09091 0.008264628 3
    3     0.40909 0.167354628 3
    4     0.04545 0.002065702 3



Create a group number for each consecutive sequence

I want to change the key of an entry in a Python dictionary.

Is there a straightforward way to do this?



Change the name of a key in dictionary

I know that `cons` returns a seq and `conj` returns a collection.  I also know that `conj` &quot;adds&quot; the item to the optimal end of the collection, and `cons` always &quot;adds&quot; the item to the front.  This example illustrates both of these points:

    user=&gt; (conj [1 2 3] 4) ; returns a collection
    [1 2 3 4]
    user=&gt; (cons 4 [1 2 3]) ; returns a seq
    (4 1 2 3)

For vectors, maps, and sets these differences make sense to me.  However, for lists they seem identical.

    user=&gt; (conj (list 3 2 1) 4) ; returns a list
    (4 3 2 1)
    user=&gt; (cons 4 (list 3 2 1)) ; returns a seq
    (4 3 2 1)

Are there any examples using lists where `conj` vs. `cons` exhibit different behaviors, or are they truly interchangeable?  Phrased differently, is there an example where a list and a seq cannot be used equivalently?



Clojure: cons (seq) vs. conj (list)

Assuming that I have a list with a huge number of items,

    l = [ 1, 4, 6, 30, 2, ... ]

I want to get the number of items from that list, where an item satisfies a certain condition. My first thought was:

    count = len([i for i in l if my_condition(l)])

But if the filtered list also has a great number of items, I think that
creating a new list for the filtered result is just a waste of memory.  For efficiency, IMHO, the above call can&#39;t be better than:

    count = 0
    for i in l:
        if my_condition(l):
            count += 1

Is there any functional-style way to get the # of items that satisfy the condition without generating a temporary list?

Get number of items from list (or other iterable) with certain condition

We&#39;re considering using UUID values as primary keys for our MySQL database. The data being inserted is generated from dozens, hundreds, or even thousands of remote computers and being inserted at a rate of 100-40,000 inserts per second, and we&#39;ll never do any updates.

The database itself will typically get to around 50M records before we start to cull data, so not a massive database, but not tiny either. We&#39;re also planing to run on InnoDB, though we are open to changing that if there is a better engine for what we&#39;re doing.

We were ready to go with Java&#39;s Type 4 UUID, but in testing have been seeing some strange behavior. For one, we&#39;re storing as varchar(36) and I now realize we&#39;d be better off using binary(16) - though how much better off I&#39;m not sure.

The bigger question is: how badly does this random data screw up the index when we have 50M records? Would we be better off if we used, for example, a type-1 UUID where the leftmost bits were timestamped? Or maybe we should ditch UUIDs entirely and consider auto_increment primary keys?

I&#39;m looking for general thoughts/tips on the performance of different types of UUIDs when they are stored as an index/primary key in MySQL. Thanks!

UUID performance in MySQL?

In python is there an easy way to tell if something is not a sequence? I tried to just do:
`if x is not sequence` but python did not like that

Python: check if an object is a sequence

Is there any command that I can run so that I can get all the sequences? 
I am using Oracle 11g. I am using Toad for Oracle to connect to it. I can visually see the sequences in Toad, but I like to know the command line for it.

How can I get all sequences in an Oracle database?

So I just came across what seems to me like a strange Python feature and wanted some clarification about it.  

The following array manipulation somewhat makes sense:

    p = [1,2,3]
    p[3:] = [4] 
    p = [1,2,3,4]

I imagine it is actually just appending this value to the end, correct?  
Why can I do this, however?  

    p[20:22] = [5,6]
    p = [1,2,3,4,5,6]
   
And even more so this:  

    p[20:100] = [7,8]
    p = [1,2,3,4,5,6,7,8]

This just seems like wrong logic. It seems like this should throw an error! 
 
 Any explanation?  
-Is it just a weird thing Python does?  
-Is there a purpose to it?  
-Or am I thinking about this the wrong way?


Why does Python allow out-of-range slice indexes for sequences?

I&#39;m having some trouble figuring out how to slice python lists, it is illustrated as follows:

    &gt;&gt;&gt; test = range(10)
    &gt;&gt;&gt; test
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    &gt;&gt;&gt; test[3:-1]
    [3, 4, 5, 6, 7, 8]
    &gt;&gt;&gt; test[3:0]
    []
    &gt;&gt;&gt; test[3:1]
    []
    &gt;&gt;&gt; test
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

To my understanding, python slice means lst[start:end], and including start, excluding end. So how would i go about finding the &quot;rest&quot; of a list starting from an element n?

Thanks a lot for all your help!

How to slice a list from an element n to the end in python?

I am learning JPA and have confusion in the `@SequenceGenerator` annotation.

To my understanding, it automatically assigns a value to the numeric identity fields/properties of an entity.

**Q1.** Does this sequence generator make use of the database&#39;s increasing numeric value generating capability or generates the number on its own?

**Q2.** If JPA uses a database auto-increment feature, then will it work with datastores that don&#39;t have an auto-increment feature?

**Q3.** If JPA generates numeric value on his own, then how does the JPA implementation know which value to generate next? Does it consult with the database first to see what value was stored last in order to generate the value (last + 1)?

---
**Q4.** Please also shed some light on `sequenceName` and `allocationSize` properties of `@SequenceGenerator` annotation.

How does the JPA @SequenceGenerator annotation work

For some reason, people in the past have inserted data without using sequence.NEXTVAL.  So when I go to use sequence.NEXTVAL in order to populate a table, I get a PK violation, since that number is already in use in the table.

How can I update the next value so that it is usable?  Right now, I&#39;m just inserting over and over until it&#39;s successful (`INSERT INTO tbl (pk) VALUES (sequence.NEXTVAL)`), and that syncs up the nextval.

All Sequence Solutions on Gang of Coders

Total of 25 Sequence Solutions